Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1 | #include "cache.h" |
Brandon Williams | b2141fc | 2017-06-14 11:07:36 -0700 | [diff] [blame] | 2 | #include "config.h" |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 3 | #include "grep.h" |
Stefan Beller | cbd53a2 | 2018-05-15 16:42:15 -0700 | [diff] [blame] | 4 | #include "object-store.h" |
René Scharfe | 60ecac9 | 2009-07-02 00:07:24 +0200 | [diff] [blame] | 5 | #include "userdiff.h" |
Johannes Schindelin | 6bfce93 | 2007-06-05 03:36:11 +0100 | [diff] [blame] | 6 | #include "xdiff-interface.h" |
Jeff King | 335ec3b | 2013-05-10 17:10:15 +0200 | [diff] [blame] | 7 | #include "diff.h" |
| 8 | #include "diffcore.h" |
Nguyễn Thái Ngọc Duy | 5c1ebcc | 2016-06-25 07:22:30 +0200 | [diff] [blame] | 9 | #include "commit.h" |
Nguyễn Thái Ngọc Duy | 793dc67 | 2016-06-25 07:22:31 +0200 | [diff] [blame] | 10 | #include "quote.h" |
Nguyễn Thái Ngọc Duy | 3ac68a9 | 2018-05-26 15:55:24 +0200 | [diff] [blame] | 11 | #include "help.h" |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 12 | |
Junio C Hamano | 07a7d65 | 2012-09-15 14:04:36 -0700 | [diff] [blame] | 13 | static int grep_source_load(struct grep_source *gs); |
Nguyễn Thái Ngọc Duy | acd00ea | 2018-09-21 17:57:33 +0200 | [diff] [blame] | 14 | static int grep_source_is_binary(struct grep_source *gs, |
| 15 | struct index_state *istate); |
Junio C Hamano | 07a7d65 | 2012-09-15 14:04:36 -0700 | [diff] [blame] | 16 | |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 17 | static struct grep_opt grep_defaults; |
| 18 | |
Nguyễn Thái Ngọc Duy | fa151dc | 2018-05-26 15:55:22 +0200 | [diff] [blame] | 19 | static const char *color_grep_slots[] = { |
| 20 | [GREP_COLOR_CONTEXT] = "context", |
| 21 | [GREP_COLOR_FILENAME] = "filename", |
| 22 | [GREP_COLOR_FUNCTION] = "function", |
| 23 | [GREP_COLOR_LINENO] = "lineNumber", |
Junio C Hamano | d036d66 | 2018-07-18 12:20:31 -0700 | [diff] [blame] | 24 | [GREP_COLOR_COLUMNNO] = "column", |
Nguyễn Thái Ngọc Duy | fa151dc | 2018-05-26 15:55:22 +0200 | [diff] [blame] | 25 | [GREP_COLOR_MATCH_CONTEXT] = "matchContext", |
| 26 | [GREP_COLOR_MATCH_SELECTED] = "matchSelected", |
| 27 | [GREP_COLOR_SELECTED] = "selected", |
| 28 | [GREP_COLOR_SEP] = "separator", |
| 29 | }; |
| 30 | |
Brandon Williams | 379642b | 2017-03-17 11:41:54 -0700 | [diff] [blame] | 31 | static void std_output(struct grep_opt *opt, const void *buf, size_t size) |
| 32 | { |
| 33 | fwrite(buf, size, 1, stdout); |
| 34 | } |
| 35 | |
Stefan Beller | 75e5e9c | 2018-02-12 17:41:30 -0800 | [diff] [blame] | 36 | static void color_set(char *dst, const char *color_bytes) |
| 37 | { |
| 38 | xsnprintf(dst, COLOR_MAXLEN, "%s", color_bytes); |
| 39 | } |
| 40 | |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 41 | /* |
| 42 | * Initialize the grep_defaults template with hardcoded defaults. |
| 43 | * We could let the compiler do this, but without C99 initializers |
| 44 | * the code gets unwieldy and unreadable, so... |
| 45 | */ |
Nguyễn Thái Ngọc Duy | 38bbc2e | 2018-09-21 17:57:23 +0200 | [diff] [blame] | 46 | void init_grep_defaults(struct repository *repo) |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 47 | { |
| 48 | struct grep_opt *opt = &grep_defaults; |
Junio C Hamano | 918d4e1 | 2012-10-09 16:40:03 -0700 | [diff] [blame] | 49 | static int run_once; |
| 50 | |
| 51 | if (run_once) |
| 52 | return; |
| 53 | run_once++; |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 54 | |
| 55 | memset(opt, 0, sizeof(*opt)); |
Nguyễn Thái Ngọc Duy | 38bbc2e | 2018-09-21 17:57:23 +0200 | [diff] [blame] | 56 | opt->repo = repo; |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 57 | opt->relative = 1; |
| 58 | opt->pathname = 1; |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 59 | opt->max_depth = -1; |
| 60 | opt->pattern_type_option = GREP_PATTERN_TYPE_UNSPECIFIED; |
Nguyễn Thái Ngọc Duy | fa151dc | 2018-05-26 15:55:22 +0200 | [diff] [blame] | 61 | color_set(opt->colors[GREP_COLOR_CONTEXT], ""); |
| 62 | color_set(opt->colors[GREP_COLOR_FILENAME], ""); |
| 63 | color_set(opt->colors[GREP_COLOR_FUNCTION], ""); |
| 64 | color_set(opt->colors[GREP_COLOR_LINENO], ""); |
Junio C Hamano | d036d66 | 2018-07-18 12:20:31 -0700 | [diff] [blame] | 65 | color_set(opt->colors[GREP_COLOR_COLUMNNO], ""); |
Nguyễn Thái Ngọc Duy | fa151dc | 2018-05-26 15:55:22 +0200 | [diff] [blame] | 66 | color_set(opt->colors[GREP_COLOR_MATCH_CONTEXT], GIT_COLOR_BOLD_RED); |
| 67 | color_set(opt->colors[GREP_COLOR_MATCH_SELECTED], GIT_COLOR_BOLD_RED); |
| 68 | color_set(opt->colors[GREP_COLOR_SELECTED], ""); |
| 69 | color_set(opt->colors[GREP_COLOR_SEP], GIT_COLOR_CYAN); |
Taylor Blau | 9d8db06 | 2018-07-09 15:33:47 -0500 | [diff] [blame] | 70 | opt->only_matching = 0; |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 71 | opt->color = -1; |
Brandon Williams | 379642b | 2017-03-17 11:41:54 -0700 | [diff] [blame] | 72 | opt->output = std_output; |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 73 | } |
| 74 | |
| 75 | static int parse_pattern_type_arg(const char *opt, const char *arg) |
| 76 | { |
| 77 | if (!strcmp(arg, "default")) |
| 78 | return GREP_PATTERN_TYPE_UNSPECIFIED; |
| 79 | else if (!strcmp(arg, "basic")) |
| 80 | return GREP_PATTERN_TYPE_BRE; |
| 81 | else if (!strcmp(arg, "extended")) |
| 82 | return GREP_PATTERN_TYPE_ERE; |
| 83 | else if (!strcmp(arg, "fixed")) |
| 84 | return GREP_PATTERN_TYPE_FIXED; |
| 85 | else if (!strcmp(arg, "perl")) |
| 86 | return GREP_PATTERN_TYPE_PCRE; |
| 87 | die("bad %s argument: %s", opt, arg); |
| 88 | } |
| 89 | |
Nguyễn Thái Ngọc Duy | 3ac68a9 | 2018-05-26 15:55:24 +0200 | [diff] [blame] | 90 | define_list_config_array_extra(color_grep_slots, {"match"}); |
| 91 | |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 92 | /* |
| 93 | * Read the configuration file once and store it in |
| 94 | * the grep_defaults template. |
| 95 | */ |
| 96 | int grep_config(const char *var, const char *value, void *cb) |
| 97 | { |
| 98 | struct grep_opt *opt = &grep_defaults; |
Nguyễn Thái Ngọc Duy | fa151dc | 2018-05-26 15:55:22 +0200 | [diff] [blame] | 99 | const char *slot; |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 100 | |
| 101 | if (userdiff_config(var, value) < 0) |
| 102 | return -1; |
| 103 | |
| 104 | if (!strcmp(var, "grep.extendedregexp")) { |
Ævar Arnfjörð Bjarmason | c7e3855 | 2017-06-29 22:22:18 +0000 | [diff] [blame] | 105 | opt->extended_regexp_option = git_config_bool(var, value); |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 106 | return 0; |
| 107 | } |
| 108 | |
| 109 | if (!strcmp(var, "grep.patterntype")) { |
| 110 | opt->pattern_type_option = parse_pattern_type_arg(var, value); |
| 111 | return 0; |
| 112 | } |
| 113 | |
| 114 | if (!strcmp(var, "grep.linenumber")) { |
| 115 | opt->linenum = git_config_bool(var, value); |
| 116 | return 0; |
| 117 | } |
Taylor Blau | 6653fec | 2018-06-22 10:49:49 -0500 | [diff] [blame] | 118 | if (!strcmp(var, "grep.column")) { |
| 119 | opt->columnnum = git_config_bool(var, value); |
| 120 | return 0; |
| 121 | } |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 122 | |
Andreas Schwab | 6453f7b | 2014-03-17 20:16:05 +0100 | [diff] [blame] | 123 | if (!strcmp(var, "grep.fullname")) { |
| 124 | opt->relative = !git_config_bool(var, value); |
| 125 | return 0; |
| 126 | } |
| 127 | |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 128 | if (!strcmp(var, "color.grep")) |
| 129 | opt->color = git_config_colorbool(var, value); |
Nguyễn Thái Ngọc Duy | fa151dc | 2018-05-26 15:55:22 +0200 | [diff] [blame] | 130 | if (!strcmp(var, "color.grep.match")) { |
| 131 | if (grep_config("color.grep.matchcontext", value, cb) < 0) |
| 132 | return -1; |
| 133 | if (grep_config("color.grep.matchselected", value, cb) < 0) |
| 134 | return -1; |
| 135 | } else if (skip_prefix(var, "color.grep.", &slot)) { |
| 136 | int i = LOOKUP_CONFIG(color_grep_slots, slot); |
| 137 | char *color; |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 138 | |
Nguyễn Thái Ngọc Duy | fa151dc | 2018-05-26 15:55:22 +0200 | [diff] [blame] | 139 | if (i < 0) |
| 140 | return -1; |
| 141 | color = opt->colors[i]; |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 142 | if (!value) |
| 143 | return config_error_nonbool(var); |
Jeff King | f6c5a29 | 2014-10-07 15:33:09 -0400 | [diff] [blame] | 144 | return color_parse(value, color); |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 145 | } |
| 146 | return 0; |
| 147 | } |
| 148 | |
| 149 | /* |
| 150 | * Initialize one instance of grep_opt and copy the |
| 151 | * default values from the template we read the configuration |
| 152 | * information in an earlier call to git_config(grep_config). |
| 153 | */ |
Nguyễn Thái Ngọc Duy | 38bbc2e | 2018-09-21 17:57:23 +0200 | [diff] [blame] | 154 | void grep_init(struct grep_opt *opt, struct repository *repo, const char *prefix) |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 155 | { |
| 156 | struct grep_opt *def = &grep_defaults; |
Nguyễn Thái Ngọc Duy | fa151dc | 2018-05-26 15:55:22 +0200 | [diff] [blame] | 157 | int i; |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 158 | |
| 159 | memset(opt, 0, sizeof(*opt)); |
Nguyễn Thái Ngọc Duy | 38bbc2e | 2018-09-21 17:57:23 +0200 | [diff] [blame] | 160 | opt->repo = repo; |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 161 | opt->prefix = prefix; |
| 162 | opt->prefix_length = (prefix && *prefix) ? strlen(prefix) : 0; |
| 163 | opt->pattern_tail = &opt->pattern_list; |
| 164 | opt->header_tail = &opt->header_list; |
| 165 | |
Taylor Blau | 9d8db06 | 2018-07-09 15:33:47 -0500 | [diff] [blame] | 166 | opt->only_matching = def->only_matching; |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 167 | opt->color = def->color; |
| 168 | opt->extended_regexp_option = def->extended_regexp_option; |
| 169 | opt->pattern_type_option = def->pattern_type_option; |
| 170 | opt->linenum = def->linenum; |
Taylor Blau | 017c0fc | 2018-06-22 10:49:39 -0500 | [diff] [blame] | 171 | opt->columnnum = def->columnnum; |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 172 | opt->max_depth = def->max_depth; |
| 173 | opt->pathname = def->pathname; |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 174 | opt->relative = def->relative; |
Brandon Williams | 379642b | 2017-03-17 11:41:54 -0700 | [diff] [blame] | 175 | opt->output = def->output; |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 176 | |
Nguyễn Thái Ngọc Duy | fa151dc | 2018-05-26 15:55:22 +0200 | [diff] [blame] | 177 | for (i = 0; i < NR_GREP_COLORS; i++) |
| 178 | color_set(opt->colors[i], def->colors[i]); |
Junio C Hamano | 7687a05 | 2012-10-09 16:17:50 -0700 | [diff] [blame] | 179 | } |
Junio C Hamano | 07a7d65 | 2012-09-15 14:04:36 -0700 | [diff] [blame] | 180 | |
Junio C Hamano | 8465541 | 2016-07-22 11:43:14 -0700 | [diff] [blame] | 181 | static void grep_set_pattern_type_option(enum grep_pattern_type pattern_type, struct grep_opt *opt) |
Junio C Hamano | c5c31d3 | 2012-10-03 14:47:48 -0700 | [diff] [blame] | 182 | { |
Ævar Arnfjörð Bjarmason | 07a3d41 | 2017-06-29 22:22:21 +0000 | [diff] [blame] | 183 | /* |
| 184 | * When committing to the pattern type by setting the relevant |
| 185 | * fields in grep_opt it's generally not necessary to zero out |
| 186 | * the fields we're not choosing, since they won't have been |
| 187 | * set by anything. The extended_regexp_option field is the |
| 188 | * only exception to this. |
| 189 | * |
| 190 | * This is because in the process of parsing grep.patternType |
| 191 | * & grep.extendedRegexp we set opt->pattern_type_option and |
| 192 | * opt->extended_regexp_option, respectively. We then |
| 193 | * internally use opt->extended_regexp_option to see if we're |
| 194 | * compiling an ERE. It must be unset if that's not actually |
| 195 | * the case. |
| 196 | */ |
| 197 | if (pattern_type != GREP_PATTERN_TYPE_ERE && |
| 198 | opt->extended_regexp_option) |
| 199 | opt->extended_regexp_option = 0; |
| 200 | |
Junio C Hamano | c5c31d3 | 2012-10-03 14:47:48 -0700 | [diff] [blame] | 201 | switch (pattern_type) { |
| 202 | case GREP_PATTERN_TYPE_UNSPECIFIED: |
| 203 | /* fall through */ |
| 204 | |
| 205 | case GREP_PATTERN_TYPE_BRE: |
Junio C Hamano | c5c31d3 | 2012-10-03 14:47:48 -0700 | [diff] [blame] | 206 | break; |
| 207 | |
| 208 | case GREP_PATTERN_TYPE_ERE: |
Ævar Arnfjörð Bjarmason | 07a3d41 | 2017-06-29 22:22:21 +0000 | [diff] [blame] | 209 | opt->extended_regexp_option = 1; |
Junio C Hamano | c5c31d3 | 2012-10-03 14:47:48 -0700 | [diff] [blame] | 210 | break; |
| 211 | |
| 212 | case GREP_PATTERN_TYPE_FIXED: |
| 213 | opt->fixed = 1; |
Junio C Hamano | c5c31d3 | 2012-10-03 14:47:48 -0700 | [diff] [blame] | 214 | break; |
| 215 | |
| 216 | case GREP_PATTERN_TYPE_PCRE: |
Ævar Arnfjörð Bjarmason | 94da919 | 2017-06-01 18:20:56 +0000 | [diff] [blame] | 217 | #ifdef USE_LIBPCRE2 |
Ævar Arnfjörð Bjarmason | 94da919 | 2017-06-01 18:20:56 +0000 | [diff] [blame] | 218 | opt->pcre2 = 1; |
| 219 | #else |
| 220 | /* |
| 221 | * It's important that pcre1 always be assigned to |
| 222 | * even when there's no USE_LIBPCRE* defined. We still |
| 223 | * call the PCRE stub function, it just dies with |
| 224 | * "cannot use Perl-compatible regexes[...]". |
| 225 | */ |
Ævar Arnfjörð Bjarmason | 6d4b574 | 2017-05-25 19:45:29 +0000 | [diff] [blame] | 226 | opt->pcre1 = 1; |
Ævar Arnfjörð Bjarmason | 94da919 | 2017-06-01 18:20:56 +0000 | [diff] [blame] | 227 | #endif |
Junio C Hamano | c5c31d3 | 2012-10-03 14:47:48 -0700 | [diff] [blame] | 228 | break; |
| 229 | } |
| 230 | } |
| 231 | |
Junio C Hamano | 8465541 | 2016-07-22 11:43:14 -0700 | [diff] [blame] | 232 | void grep_commit_pattern_type(enum grep_pattern_type pattern_type, struct grep_opt *opt) |
| 233 | { |
| 234 | if (pattern_type != GREP_PATTERN_TYPE_UNSPECIFIED) |
| 235 | grep_set_pattern_type_option(pattern_type, opt); |
| 236 | else if (opt->pattern_type_option != GREP_PATTERN_TYPE_UNSPECIFIED) |
| 237 | grep_set_pattern_type_option(opt->pattern_type_option, opt); |
| 238 | else if (opt->extended_regexp_option) |
Ævar Arnfjörð Bjarmason | 07a3d41 | 2017-06-29 22:22:21 +0000 | [diff] [blame] | 239 | /* |
| 240 | * This branch *must* happen after setting from the |
| 241 | * opt->pattern_type_option above, we don't want |
| 242 | * grep.extendedRegexp to override grep.patternType! |
| 243 | */ |
Junio C Hamano | 8465541 | 2016-07-22 11:43:14 -0700 | [diff] [blame] | 244 | grep_set_pattern_type_option(GREP_PATTERN_TYPE_ERE, opt); |
| 245 | } |
| 246 | |
René Scharfe | fc45675 | 2012-05-20 16:32:39 +0200 | [diff] [blame] | 247 | static struct grep_pat *create_grep_pat(const char *pat, size_t patlen, |
| 248 | const char *origin, int no, |
| 249 | enum grep_pat_token t, |
| 250 | enum grep_header_field field) |
Junio C Hamano | a4d7d2c | 2008-09-04 22:15:02 -0700 | [diff] [blame] | 251 | { |
| 252 | struct grep_pat *p = xcalloc(1, sizeof(*p)); |
René Scharfe | 526a858 | 2012-05-20 16:33:07 +0200 | [diff] [blame] | 253 | p->pattern = xmemdupz(pat, patlen); |
René Scharfe | fc45675 | 2012-05-20 16:32:39 +0200 | [diff] [blame] | 254 | p->patternlen = patlen; |
| 255 | p->origin = origin; |
| 256 | p->no = no; |
| 257 | p->token = t; |
Junio C Hamano | a4d7d2c | 2008-09-04 22:15:02 -0700 | [diff] [blame] | 258 | p->field = field; |
René Scharfe | fc45675 | 2012-05-20 16:32:39 +0200 | [diff] [blame] | 259 | return p; |
| 260 | } |
| 261 | |
René Scharfe | 2b3873f | 2012-05-20 16:32:54 +0200 | [diff] [blame] | 262 | static void do_append_grep_pat(struct grep_pat ***tail, struct grep_pat *p) |
| 263 | { |
| 264 | **tail = p; |
| 265 | *tail = &p->next; |
Junio C Hamano | a4d7d2c | 2008-09-04 22:15:02 -0700 | [diff] [blame] | 266 | p->next = NULL; |
René Scharfe | 526a858 | 2012-05-20 16:33:07 +0200 | [diff] [blame] | 267 | |
| 268 | switch (p->token) { |
| 269 | case GREP_PATTERN: /* atom */ |
| 270 | case GREP_PATTERN_HEAD: |
| 271 | case GREP_PATTERN_BODY: |
| 272 | for (;;) { |
| 273 | struct grep_pat *new_pat; |
| 274 | size_t len = 0; |
| 275 | char *cp = p->pattern + p->patternlen, *nl = NULL; |
| 276 | while (++len <= p->patternlen) { |
| 277 | if (*(--cp) == '\n') { |
| 278 | nl = cp; |
| 279 | break; |
| 280 | } |
| 281 | } |
| 282 | if (!nl) |
| 283 | break; |
| 284 | new_pat = create_grep_pat(nl + 1, len - 1, p->origin, |
| 285 | p->no, p->token, p->field); |
| 286 | new_pat->next = p->next; |
| 287 | if (!p->next) |
| 288 | *tail = &new_pat->next; |
| 289 | p->next = new_pat; |
| 290 | *nl = '\0'; |
| 291 | p->patternlen -= len; |
| 292 | } |
| 293 | break; |
| 294 | default: |
| 295 | break; |
| 296 | } |
René Scharfe | 2b3873f | 2012-05-20 16:32:54 +0200 | [diff] [blame] | 297 | } |
| 298 | |
René Scharfe | fc45675 | 2012-05-20 16:32:39 +0200 | [diff] [blame] | 299 | void append_header_grep_pattern(struct grep_opt *opt, |
| 300 | enum grep_header_field field, const char *pat) |
| 301 | { |
| 302 | struct grep_pat *p = create_grep_pat(pat, strlen(pat), "header", 0, |
| 303 | GREP_PATTERN_HEAD, field); |
Junio C Hamano | baa6378 | 2012-09-29 11:59:52 -0700 | [diff] [blame] | 304 | if (field == GREP_HEADER_REFLOG) |
| 305 | opt->use_reflog_filter = 1; |
René Scharfe | 2b3873f | 2012-05-20 16:32:54 +0200 | [diff] [blame] | 306 | do_append_grep_pat(&opt->header_tail, p); |
Junio C Hamano | a4d7d2c | 2008-09-04 22:15:02 -0700 | [diff] [blame] | 307 | } |
| 308 | |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 309 | void append_grep_pattern(struct grep_opt *opt, const char *pat, |
| 310 | const char *origin, int no, enum grep_pat_token t) |
| 311 | { |
René Scharfe | ed40a09 | 2010-05-22 23:43:43 +0200 | [diff] [blame] | 312 | append_grep_pat(opt, pat, strlen(pat), origin, no, t); |
| 313 | } |
| 314 | |
| 315 | void append_grep_pat(struct grep_opt *opt, const char *pat, size_t patlen, |
| 316 | const char *origin, int no, enum grep_pat_token t) |
| 317 | { |
René Scharfe | fc45675 | 2012-05-20 16:32:39 +0200 | [diff] [blame] | 318 | struct grep_pat *p = create_grep_pat(pat, patlen, origin, no, t, 0); |
René Scharfe | 2b3873f | 2012-05-20 16:32:54 +0200 | [diff] [blame] | 319 | do_append_grep_pat(&opt->pattern_tail, p); |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 320 | } |
| 321 | |
Fredrik Kuivinen | 5b594f4 | 2010-01-25 23:51:39 +0100 | [diff] [blame] | 322 | struct grep_opt *grep_opt_dup(const struct grep_opt *opt) |
| 323 | { |
| 324 | struct grep_pat *pat; |
| 325 | struct grep_opt *ret = xmalloc(sizeof(struct grep_opt)); |
| 326 | *ret = *opt; |
| 327 | |
| 328 | ret->pattern_list = NULL; |
| 329 | ret->pattern_tail = &ret->pattern_list; |
| 330 | |
| 331 | for(pat = opt->pattern_list; pat != NULL; pat = pat->next) |
| 332 | { |
| 333 | if(pat->token == GREP_PATTERN_HEAD) |
| 334 | append_header_grep_pattern(ret, pat->field, |
| 335 | pat->pattern); |
| 336 | else |
René Scharfe | ed40a09 | 2010-05-22 23:43:43 +0200 | [diff] [blame] | 337 | append_grep_pat(ret, pat->pattern, pat->patternlen, |
| 338 | pat->origin, pat->no, pat->token); |
Fredrik Kuivinen | 5b594f4 | 2010-01-25 23:51:39 +0100 | [diff] [blame] | 339 | } |
| 340 | |
| 341 | return ret; |
| 342 | } |
| 343 | |
Michał Kiedrowicz | a30c148 | 2011-05-09 23:52:04 +0200 | [diff] [blame] | 344 | static NORETURN void compile_regexp_failed(const struct grep_pat *p, |
| 345 | const char *error) |
| 346 | { |
| 347 | char where[1024]; |
| 348 | |
| 349 | if (p->no) |
Jeff King | 19bdd3e | 2015-09-24 17:06:51 -0400 | [diff] [blame] | 350 | xsnprintf(where, sizeof(where), "In '%s' at %d, ", p->origin, p->no); |
Michał Kiedrowicz | a30c148 | 2011-05-09 23:52:04 +0200 | [diff] [blame] | 351 | else if (p->origin) |
Jeff King | 19bdd3e | 2015-09-24 17:06:51 -0400 | [diff] [blame] | 352 | xsnprintf(where, sizeof(where), "%s, ", p->origin); |
Michał Kiedrowicz | a30c148 | 2011-05-09 23:52:04 +0200 | [diff] [blame] | 353 | else |
| 354 | where[0] = 0; |
| 355 | |
| 356 | die("%s'%s': %s", where, p->pattern, error); |
| 357 | } |
| 358 | |
Ævar Arnfjörð Bjarmason | 543f1c0 | 2017-05-25 19:45:30 +0000 | [diff] [blame] | 359 | static int is_fixed(const char *s, size_t len) |
| 360 | { |
| 361 | size_t i; |
| 362 | |
| 363 | for (i = 0; i < len; i++) { |
| 364 | if (is_regex_special(s[i])) |
| 365 | return 0; |
| 366 | } |
| 367 | |
| 368 | return 1; |
| 369 | } |
| 370 | |
Ævar Arnfjörð Bjarmason | 219e65b | 2017-05-25 19:45:27 +0000 | [diff] [blame] | 371 | static int has_null(const char *s, size_t len) |
| 372 | { |
| 373 | /* |
| 374 | * regcomp cannot accept patterns with NULs so when using it |
| 375 | * we consider any pattern containing a NUL fixed. |
| 376 | */ |
| 377 | if (memchr(s, 0, len)) |
| 378 | return 1; |
| 379 | |
| 380 | return 0; |
| 381 | } |
| 382 | |
Ævar Arnfjörð Bjarmason | 3485bea | 2017-05-25 19:45:28 +0000 | [diff] [blame] | 383 | #ifdef USE_LIBPCRE1 |
Ævar Arnfjörð Bjarmason | 6d4b574 | 2017-05-25 19:45:29 +0000 | [diff] [blame] | 384 | static void compile_pcre1_regexp(struct grep_pat *p, const struct grep_opt *opt) |
Michał Kiedrowicz | 63e7e9d | 2011-05-09 23:52:05 +0200 | [diff] [blame] | 385 | { |
| 386 | const char *error; |
| 387 | int erroffset; |
Michał Kiedrowicz | fba4f12 | 2012-02-25 10:24:28 +0100 | [diff] [blame] | 388 | int options = PCRE_MULTILINE; |
Michał Kiedrowicz | 63e7e9d | 2011-05-09 23:52:05 +0200 | [diff] [blame] | 389 | |
Nguyễn Thái Ngọc Duy | 9d9babb | 2016-06-25 07:22:33 +0200 | [diff] [blame] | 390 | if (opt->ignore_case) { |
| 391 | if (has_non_ascii(p->pattern)) |
Ævar Arnfjörð Bjarmason | 6d4b574 | 2017-05-25 19:45:29 +0000 | [diff] [blame] | 392 | p->pcre1_tables = pcre_maketables(); |
Michał Kiedrowicz | 63e7e9d | 2011-05-09 23:52:05 +0200 | [diff] [blame] | 393 | options |= PCRE_CASELESS; |
Nguyễn Thái Ngọc Duy | 9d9babb | 2016-06-25 07:22:33 +0200 | [diff] [blame] | 394 | } |
Nguyễn Thái Ngọc Duy | 18547aa | 2016-06-25 07:22:35 +0200 | [diff] [blame] | 395 | if (is_utf8_locale() && has_non_ascii(p->pattern)) |
| 396 | options |= PCRE_UTF8; |
Michał Kiedrowicz | 63e7e9d | 2011-05-09 23:52:05 +0200 | [diff] [blame] | 397 | |
Ævar Arnfjörð Bjarmason | 6d4b574 | 2017-05-25 19:45:29 +0000 | [diff] [blame] | 398 | p->pcre1_regexp = pcre_compile(p->pattern, options, &error, &erroffset, |
| 399 | p->pcre1_tables); |
| 400 | if (!p->pcre1_regexp) |
Michał Kiedrowicz | 63e7e9d | 2011-05-09 23:52:05 +0200 | [diff] [blame] | 401 | compile_regexp_failed(p, error); |
| 402 | |
Charles Bailey | 2fff1e1 | 2017-11-12 16:59:38 +0000 | [diff] [blame] | 403 | p->pcre1_extra_info = pcre_study(p->pcre1_regexp, GIT_PCRE_STUDY_JIT_COMPILE, &error); |
Ævar Arnfjörð Bjarmason | 6d4b574 | 2017-05-25 19:45:29 +0000 | [diff] [blame] | 404 | if (!p->pcre1_extra_info && error) |
Michał Kiedrowicz | 63e7e9d | 2011-05-09 23:52:05 +0200 | [diff] [blame] | 405 | die("%s", error); |
Ævar Arnfjörð Bjarmason | fbaceaa | 2017-05-25 20:05:25 +0000 | [diff] [blame] | 406 | |
Ævar Arnfjörð Bjarmason | e87de7c | 2017-05-25 20:05:26 +0000 | [diff] [blame] | 407 | #ifdef GIT_PCRE1_USE_JIT |
Ævar Arnfjörð Bjarmason | fbaceaa | 2017-05-25 20:05:25 +0000 | [diff] [blame] | 408 | pcre_config(PCRE_CONFIG_JIT, &p->pcre1_jit_on); |
| 409 | if (p->pcre1_jit_on == 1) { |
| 410 | p->pcre1_jit_stack = pcre_jit_stack_alloc(1, 1024 * 1024); |
| 411 | if (!p->pcre1_jit_stack) |
| 412 | die("Couldn't allocate PCRE JIT stack"); |
| 413 | pcre_assign_jit_stack(p->pcre1_extra_info, NULL, p->pcre1_jit_stack); |
| 414 | } else if (p->pcre1_jit_on != 0) { |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 415 | BUG("The pcre1_jit_on variable should be 0 or 1, not %d", |
Ævar Arnfjörð Bjarmason | fbaceaa | 2017-05-25 20:05:25 +0000 | [diff] [blame] | 416 | p->pcre1_jit_on); |
| 417 | } |
| 418 | #endif |
Michał Kiedrowicz | 63e7e9d | 2011-05-09 23:52:05 +0200 | [diff] [blame] | 419 | } |
| 420 | |
Ævar Arnfjörð Bjarmason | 6d4b574 | 2017-05-25 19:45:29 +0000 | [diff] [blame] | 421 | static int pcre1match(struct grep_pat *p, const char *line, const char *eol, |
Michał Kiedrowicz | 63e7e9d | 2011-05-09 23:52:05 +0200 | [diff] [blame] | 422 | regmatch_t *match, int eflags) |
| 423 | { |
| 424 | int ovector[30], ret, flags = 0; |
| 425 | |
| 426 | if (eflags & REG_NOTBOL) |
| 427 | flags |= PCRE_NOTBOL; |
| 428 | |
Ævar Arnfjörð Bjarmason | e87de7c | 2017-05-25 20:05:26 +0000 | [diff] [blame] | 429 | #ifdef GIT_PCRE1_USE_JIT |
Ævar Arnfjörð Bjarmason | fbaceaa | 2017-05-25 20:05:25 +0000 | [diff] [blame] | 430 | if (p->pcre1_jit_on) { |
| 431 | ret = pcre_jit_exec(p->pcre1_regexp, p->pcre1_extra_info, line, |
| 432 | eol - line, 0, flags, ovector, |
| 433 | ARRAY_SIZE(ovector), p->pcre1_jit_stack); |
| 434 | } else |
| 435 | #endif |
| 436 | { |
| 437 | ret = pcre_exec(p->pcre1_regexp, p->pcre1_extra_info, line, |
| 438 | eol - line, 0, flags, ovector, |
| 439 | ARRAY_SIZE(ovector)); |
| 440 | } |
| 441 | |
Michał Kiedrowicz | 63e7e9d | 2011-05-09 23:52:05 +0200 | [diff] [blame] | 442 | if (ret < 0 && ret != PCRE_ERROR_NOMATCH) |
| 443 | die("pcre_exec failed with error code %d", ret); |
| 444 | if (ret > 0) { |
| 445 | ret = 0; |
| 446 | match->rm_so = ovector[0]; |
| 447 | match->rm_eo = ovector[1]; |
| 448 | } |
| 449 | |
| 450 | return ret; |
| 451 | } |
| 452 | |
Ævar Arnfjörð Bjarmason | 6d4b574 | 2017-05-25 19:45:29 +0000 | [diff] [blame] | 453 | static void free_pcre1_regexp(struct grep_pat *p) |
Michał Kiedrowicz | 63e7e9d | 2011-05-09 23:52:05 +0200 | [diff] [blame] | 454 | { |
Ævar Arnfjörð Bjarmason | 6d4b574 | 2017-05-25 19:45:29 +0000 | [diff] [blame] | 455 | pcre_free(p->pcre1_regexp); |
Ævar Arnfjörð Bjarmason | e87de7c | 2017-05-25 20:05:26 +0000 | [diff] [blame] | 456 | #ifdef GIT_PCRE1_USE_JIT |
Ævar Arnfjörð Bjarmason | fbaceaa | 2017-05-25 20:05:25 +0000 | [diff] [blame] | 457 | if (p->pcre1_jit_on) { |
| 458 | pcre_free_study(p->pcre1_extra_info); |
| 459 | pcre_jit_stack_free(p->pcre1_jit_stack); |
| 460 | } else |
| 461 | #endif |
| 462 | { |
| 463 | pcre_free(p->pcre1_extra_info); |
| 464 | } |
Ævar Arnfjörð Bjarmason | 6d4b574 | 2017-05-25 19:45:29 +0000 | [diff] [blame] | 465 | pcre_free((void *)p->pcre1_tables); |
Michał Kiedrowicz | 63e7e9d | 2011-05-09 23:52:05 +0200 | [diff] [blame] | 466 | } |
Ævar Arnfjörð Bjarmason | 3485bea | 2017-05-25 19:45:28 +0000 | [diff] [blame] | 467 | #else /* !USE_LIBPCRE1 */ |
Ævar Arnfjörð Bjarmason | 6d4b574 | 2017-05-25 19:45:29 +0000 | [diff] [blame] | 468 | static void compile_pcre1_regexp(struct grep_pat *p, const struct grep_opt *opt) |
Michał Kiedrowicz | 63e7e9d | 2011-05-09 23:52:05 +0200 | [diff] [blame] | 469 | { |
| 470 | die("cannot use Perl-compatible regexes when not compiled with USE_LIBPCRE"); |
| 471 | } |
| 472 | |
Ævar Arnfjörð Bjarmason | 6d4b574 | 2017-05-25 19:45:29 +0000 | [diff] [blame] | 473 | static int pcre1match(struct grep_pat *p, const char *line, const char *eol, |
Michał Kiedrowicz | 63e7e9d | 2011-05-09 23:52:05 +0200 | [diff] [blame] | 474 | regmatch_t *match, int eflags) |
| 475 | { |
| 476 | return 1; |
| 477 | } |
| 478 | |
Ævar Arnfjörð Bjarmason | 6d4b574 | 2017-05-25 19:45:29 +0000 | [diff] [blame] | 479 | static void free_pcre1_regexp(struct grep_pat *p) |
Michał Kiedrowicz | 63e7e9d | 2011-05-09 23:52:05 +0200 | [diff] [blame] | 480 | { |
| 481 | } |
Ævar Arnfjörð Bjarmason | 3485bea | 2017-05-25 19:45:28 +0000 | [diff] [blame] | 482 | #endif /* !USE_LIBPCRE1 */ |
Michał Kiedrowicz | 63e7e9d | 2011-05-09 23:52:05 +0200 | [diff] [blame] | 483 | |
Ævar Arnfjörð Bjarmason | 94da919 | 2017-06-01 18:20:56 +0000 | [diff] [blame] | 484 | #ifdef USE_LIBPCRE2 |
| 485 | static void compile_pcre2_pattern(struct grep_pat *p, const struct grep_opt *opt) |
| 486 | { |
| 487 | int error; |
| 488 | PCRE2_UCHAR errbuf[256]; |
| 489 | PCRE2_SIZE erroffset; |
| 490 | int options = PCRE2_MULTILINE; |
| 491 | const uint8_t *character_tables = NULL; |
| 492 | int jitret; |
Ævar Arnfjörð Bjarmason | a25b908 | 2017-11-23 14:16:58 +0000 | [diff] [blame] | 493 | int patinforet; |
| 494 | size_t jitsizearg; |
Ævar Arnfjörð Bjarmason | 94da919 | 2017-06-01 18:20:56 +0000 | [diff] [blame] | 495 | |
| 496 | assert(opt->pcre2); |
| 497 | |
| 498 | p->pcre2_compile_context = NULL; |
| 499 | |
| 500 | if (opt->ignore_case) { |
| 501 | if (has_non_ascii(p->pattern)) { |
| 502 | character_tables = pcre2_maketables(NULL); |
| 503 | p->pcre2_compile_context = pcre2_compile_context_create(NULL); |
| 504 | pcre2_set_character_tables(p->pcre2_compile_context, character_tables); |
| 505 | } |
| 506 | options |= PCRE2_CASELESS; |
| 507 | } |
| 508 | if (is_utf8_locale() && has_non_ascii(p->pattern)) |
| 509 | options |= PCRE2_UTF; |
| 510 | |
| 511 | p->pcre2_pattern = pcre2_compile((PCRE2_SPTR)p->pattern, |
| 512 | p->patternlen, options, &error, &erroffset, |
| 513 | p->pcre2_compile_context); |
| 514 | |
| 515 | if (p->pcre2_pattern) { |
| 516 | p->pcre2_match_data = pcre2_match_data_create_from_pattern(p->pcre2_pattern, NULL); |
| 517 | if (!p->pcre2_match_data) |
| 518 | die("Couldn't allocate PCRE2 match data"); |
| 519 | } else { |
| 520 | pcre2_get_error_message(error, errbuf, sizeof(errbuf)); |
| 521 | compile_regexp_failed(p, (const char *)&errbuf); |
| 522 | } |
| 523 | |
| 524 | pcre2_config(PCRE2_CONFIG_JIT, &p->pcre2_jit_on); |
| 525 | if (p->pcre2_jit_on == 1) { |
| 526 | jitret = pcre2_jit_compile(p->pcre2_pattern, PCRE2_JIT_COMPLETE); |
| 527 | if (jitret) |
| 528 | die("Couldn't JIT the PCRE2 pattern '%s', got '%d'\n", p->pattern, jitret); |
Ævar Arnfjörð Bjarmason | a25b908 | 2017-11-23 14:16:58 +0000 | [diff] [blame] | 529 | |
| 530 | /* |
| 531 | * The pcre2_config(PCRE2_CONFIG_JIT, ...) call just |
| 532 | * tells us whether the library itself supports JIT, |
| 533 | * but to see whether we're going to be actually using |
| 534 | * JIT we need to extract PCRE2_INFO_JITSIZE from the |
| 535 | * pattern *after* we do pcre2_jit_compile() above. |
| 536 | * |
| 537 | * This is because if the pattern contains the |
| 538 | * (*NO_JIT) verb (see pcre2syntax(3)) |
| 539 | * pcre2_jit_compile() will exit early with 0. If we |
| 540 | * then proceed to call pcre2_jit_match() further down |
| 541 | * the line instead of pcre2_match() we'll either |
| 542 | * segfault (pre PCRE 10.31) or run into a fatal error |
| 543 | * (post PCRE2 10.31) |
| 544 | */ |
| 545 | patinforet = pcre2_pattern_info(p->pcre2_pattern, PCRE2_INFO_JITSIZE, &jitsizearg); |
| 546 | if (patinforet) |
| 547 | BUG("pcre2_pattern_info() failed: %d", patinforet); |
| 548 | if (jitsizearg == 0) { |
| 549 | p->pcre2_jit_on = 0; |
| 550 | return; |
| 551 | } |
| 552 | |
Ævar Arnfjörð Bjarmason | 94da919 | 2017-06-01 18:20:56 +0000 | [diff] [blame] | 553 | p->pcre2_jit_stack = pcre2_jit_stack_create(1, 1024 * 1024, NULL); |
| 554 | if (!p->pcre2_jit_stack) |
| 555 | die("Couldn't allocate PCRE2 JIT stack"); |
| 556 | p->pcre2_match_context = pcre2_match_context_create(NULL); |
Ævar Arnfjörð Bjarmason | 674ad93 | 2017-06-19 22:01:48 +0000 | [diff] [blame] | 557 | if (!p->pcre2_match_context) |
Ævar Arnfjörð Bjarmason | 94da919 | 2017-06-01 18:20:56 +0000 | [diff] [blame] | 558 | die("Couldn't allocate PCRE2 match context"); |
| 559 | pcre2_jit_stack_assign(p->pcre2_match_context, NULL, p->pcre2_jit_stack); |
| 560 | } else if (p->pcre2_jit_on != 0) { |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 561 | BUG("The pcre2_jit_on variable should be 0 or 1, not %d", |
Ævar Arnfjörð Bjarmason | 94da919 | 2017-06-01 18:20:56 +0000 | [diff] [blame] | 562 | p->pcre1_jit_on); |
| 563 | } |
| 564 | } |
| 565 | |
| 566 | static int pcre2match(struct grep_pat *p, const char *line, const char *eol, |
| 567 | regmatch_t *match, int eflags) |
| 568 | { |
| 569 | int ret, flags = 0; |
| 570 | PCRE2_SIZE *ovector; |
| 571 | PCRE2_UCHAR errbuf[256]; |
| 572 | |
| 573 | if (eflags & REG_NOTBOL) |
| 574 | flags |= PCRE2_NOTBOL; |
| 575 | |
| 576 | if (p->pcre2_jit_on) |
| 577 | ret = pcre2_jit_match(p->pcre2_pattern, (unsigned char *)line, |
| 578 | eol - line, 0, flags, p->pcre2_match_data, |
| 579 | NULL); |
| 580 | else |
| 581 | ret = pcre2_match(p->pcre2_pattern, (unsigned char *)line, |
| 582 | eol - line, 0, flags, p->pcre2_match_data, |
| 583 | NULL); |
| 584 | |
| 585 | if (ret < 0 && ret != PCRE2_ERROR_NOMATCH) { |
| 586 | pcre2_get_error_message(ret, errbuf, sizeof(errbuf)); |
| 587 | die("%s failed with error code %d: %s", |
| 588 | (p->pcre2_jit_on ? "pcre2_jit_match" : "pcre2_match"), ret, |
| 589 | errbuf); |
| 590 | } |
| 591 | if (ret > 0) { |
| 592 | ovector = pcre2_get_ovector_pointer(p->pcre2_match_data); |
| 593 | ret = 0; |
| 594 | match->rm_so = (int)ovector[0]; |
| 595 | match->rm_eo = (int)ovector[1]; |
| 596 | } |
| 597 | |
| 598 | return ret; |
| 599 | } |
| 600 | |
| 601 | static void free_pcre2_pattern(struct grep_pat *p) |
| 602 | { |
| 603 | pcre2_compile_context_free(p->pcre2_compile_context); |
| 604 | pcre2_code_free(p->pcre2_pattern); |
| 605 | pcre2_match_data_free(p->pcre2_match_data); |
| 606 | pcre2_jit_stack_free(p->pcre2_jit_stack); |
| 607 | pcre2_match_context_free(p->pcre2_match_context); |
| 608 | } |
| 609 | #else /* !USE_LIBPCRE2 */ |
| 610 | static void compile_pcre2_pattern(struct grep_pat *p, const struct grep_opt *opt) |
| 611 | { |
| 612 | /* |
| 613 | * Unreachable until USE_LIBPCRE2 becomes synonymous with |
| 614 | * USE_LIBPCRE. See the sibling comment in |
| 615 | * grep_set_pattern_type_option(). |
| 616 | */ |
| 617 | die("cannot use Perl-compatible regexes when not compiled with USE_LIBPCRE"); |
| 618 | } |
| 619 | |
| 620 | static int pcre2match(struct grep_pat *p, const char *line, const char *eol, |
| 621 | regmatch_t *match, int eflags) |
| 622 | { |
| 623 | return 1; |
| 624 | } |
| 625 | |
| 626 | static void free_pcre2_pattern(struct grep_pat *p) |
| 627 | { |
| 628 | } |
| 629 | #endif /* !USE_LIBPCRE2 */ |
| 630 | |
Nguyễn Thái Ngọc Duy | 793dc67 | 2016-06-25 07:22:31 +0200 | [diff] [blame] | 631 | static void compile_fixed_regexp(struct grep_pat *p, struct grep_opt *opt) |
| 632 | { |
| 633 | struct strbuf sb = STRBUF_INIT; |
| 634 | int err; |
Ævar Arnfjörð Bjarmason | 1ceabab | 2017-06-29 22:22:22 +0000 | [diff] [blame] | 635 | int regflags = 0; |
Nguyễn Thái Ngọc Duy | 793dc67 | 2016-06-25 07:22:31 +0200 | [diff] [blame] | 636 | |
| 637 | basic_regex_quote_buf(&sb, p->pattern); |
Nguyễn Thái Ngọc Duy | 793dc67 | 2016-06-25 07:22:31 +0200 | [diff] [blame] | 638 | if (opt->ignore_case) |
| 639 | regflags |= REG_ICASE; |
| 640 | err = regcomp(&p->regexp, sb.buf, regflags); |
| 641 | if (opt->debug) |
| 642 | fprintf(stderr, "fixed %s\n", sb.buf); |
| 643 | strbuf_release(&sb); |
| 644 | if (err) { |
| 645 | char errbuf[1024]; |
| 646 | regerror(err, &p->regexp, errbuf, sizeof(errbuf)); |
Nguyễn Thái Ngọc Duy | 793dc67 | 2016-06-25 07:22:31 +0200 | [diff] [blame] | 647 | compile_regexp_failed(p, errbuf); |
| 648 | } |
| 649 | } |
| 650 | |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 651 | static void compile_regexp(struct grep_pat *p, struct grep_opt *opt) |
| 652 | { |
Ævar Arnfjörð Bjarmason | 07a3d41 | 2017-06-29 22:22:21 +0000 | [diff] [blame] | 653 | int ascii_only; |
René Scharfe | c822255 | 2009-01-10 00:18:34 +0100 | [diff] [blame] | 654 | int err; |
Ævar Arnfjörð Bjarmason | 07a3d41 | 2017-06-29 22:22:21 +0000 | [diff] [blame] | 655 | int regflags = REG_NEWLINE; |
René Scharfe | c822255 | 2009-01-10 00:18:34 +0100 | [diff] [blame] | 656 | |
René Scharfe | d7eb527 | 2009-03-07 13:28:40 +0100 | [diff] [blame] | 657 | p->word_regexp = opt->word_regexp; |
Brian Collins | 5183bf6 | 2009-11-06 01:22:35 -0800 | [diff] [blame] | 658 | p->ignore_case = opt->ignore_case; |
Nguyễn Thái Ngọc Duy | 5c1ebcc | 2016-06-25 07:22:30 +0200 | [diff] [blame] | 659 | ascii_only = !has_non_ascii(p->pattern); |
René Scharfe | d7eb527 | 2009-03-07 13:28:40 +0100 | [diff] [blame] | 660 | |
Nguyễn Thái Ngọc Duy | 793dc67 | 2016-06-25 07:22:31 +0200 | [diff] [blame] | 661 | /* |
| 662 | * Even when -F (fixed) asks us to do a non-regexp search, we |
| 663 | * may not be able to correctly case-fold when -i |
| 664 | * (ignore-case) is asked (in which case, we'll synthesize a |
| 665 | * regexp to match the pattern that matches regexp special |
| 666 | * characters literally, while ignoring case differences). On |
| 667 | * the other hand, even without -F, if the pattern does not |
| 668 | * have any regexp special characters and there is no need for |
| 669 | * case-folding search, we can internally turn it into a |
| 670 | * simple string match using kws. p->fixed tells us if we |
| 671 | * want to use kws. |
| 672 | */ |
Ævar Arnfjörð Bjarmason | 219e65b | 2017-05-25 19:45:27 +0000 | [diff] [blame] | 673 | if (opt->fixed || |
| 674 | has_null(p->pattern, p->patternlen) || |
| 675 | is_fixed(p->pattern, p->patternlen)) |
Ævar Arnfjörð Bjarmason | 07a3d41 | 2017-06-29 22:22:21 +0000 | [diff] [blame] | 676 | p->fixed = !p->ignore_case || ascii_only; |
Fredrik Kuivinen | 9ecedde | 2011-08-21 00:42:18 +0200 | [diff] [blame] | 677 | |
| 678 | if (p->fixed) { |
Ævar Arnfjörð Bjarmason | 07a3d41 | 2017-06-29 22:22:21 +0000 | [diff] [blame] | 679 | p->kws = kwsalloc(p->ignore_case ? tolower_trans_tbl : NULL); |
Fredrik Kuivinen | 9ecedde | 2011-08-21 00:42:18 +0200 | [diff] [blame] | 680 | kwsincr(p->kws, p->pattern, p->patternlen); |
| 681 | kwsprep(p->kws); |
René Scharfe | c822255 | 2009-01-10 00:18:34 +0100 | [diff] [blame] | 682 | return; |
Nguyễn Thái Ngọc Duy | 793dc67 | 2016-06-25 07:22:31 +0200 | [diff] [blame] | 683 | } else if (opt->fixed) { |
| 684 | /* |
| 685 | * We come here when the pattern has the non-ascii |
| 686 | * characters we cannot case-fold, and asked to |
| 687 | * ignore-case. |
| 688 | */ |
| 689 | compile_fixed_regexp(p, opt); |
| 690 | return; |
Fredrik Kuivinen | 9ecedde | 2011-08-21 00:42:18 +0200 | [diff] [blame] | 691 | } |
René Scharfe | c822255 | 2009-01-10 00:18:34 +0100 | [diff] [blame] | 692 | |
Ævar Arnfjörð Bjarmason | 94da919 | 2017-06-01 18:20:56 +0000 | [diff] [blame] | 693 | if (opt->pcre2) { |
| 694 | compile_pcre2_pattern(p, opt); |
| 695 | return; |
| 696 | } |
| 697 | |
Ævar Arnfjörð Bjarmason | 6d4b574 | 2017-05-25 19:45:29 +0000 | [diff] [blame] | 698 | if (opt->pcre1) { |
| 699 | compile_pcre1_regexp(p, opt); |
Michał Kiedrowicz | 63e7e9d | 2011-05-09 23:52:05 +0200 | [diff] [blame] | 700 | return; |
| 701 | } |
| 702 | |
Ævar Arnfjörð Bjarmason | 07a3d41 | 2017-06-29 22:22:21 +0000 | [diff] [blame] | 703 | if (p->ignore_case) |
| 704 | regflags |= REG_ICASE; |
| 705 | if (opt->extended_regexp_option) |
| 706 | regflags |= REG_EXTENDED; |
| 707 | err = regcomp(&p->regexp, p->pattern, regflags); |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 708 | if (err) { |
| 709 | char errbuf[1024]; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 710 | regerror(err, &p->regexp, errbuf, 1024); |
Michał Kiedrowicz | a30c148 | 2011-05-09 23:52:04 +0200 | [diff] [blame] | 711 | compile_regexp_failed(p, errbuf); |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 712 | } |
| 713 | } |
| 714 | |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 715 | static struct grep_expr *compile_pattern_or(struct grep_pat **); |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 716 | static struct grep_expr *compile_pattern_atom(struct grep_pat **list) |
| 717 | { |
| 718 | struct grep_pat *p; |
| 719 | struct grep_expr *x; |
| 720 | |
| 721 | p = *list; |
Linus Torvalds | c922b01 | 2009-04-27 11:10:24 -0700 | [diff] [blame] | 722 | if (!p) |
| 723 | return NULL; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 724 | switch (p->token) { |
| 725 | case GREP_PATTERN: /* atom */ |
Junio C Hamano | 480c1ca | 2006-09-20 12:39:46 -0700 | [diff] [blame] | 726 | case GREP_PATTERN_HEAD: |
| 727 | case GREP_PATTERN_BODY: |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 728 | x = xcalloc(1, sizeof (struct grep_expr)); |
| 729 | x->node = GREP_NODE_ATOM; |
| 730 | x->u.atom = p; |
| 731 | *list = p->next; |
| 732 | return x; |
| 733 | case GREP_OPEN_PAREN: |
| 734 | *list = p->next; |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 735 | x = compile_pattern_or(list); |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 736 | if (!*list || (*list)->token != GREP_CLOSE_PAREN) |
| 737 | die("unmatched parenthesis"); |
| 738 | *list = (*list)->next; |
| 739 | return x; |
| 740 | default: |
| 741 | return NULL; |
| 742 | } |
| 743 | } |
| 744 | |
| 745 | static struct grep_expr *compile_pattern_not(struct grep_pat **list) |
| 746 | { |
| 747 | struct grep_pat *p; |
| 748 | struct grep_expr *x; |
| 749 | |
| 750 | p = *list; |
Linus Torvalds | c922b01 | 2009-04-27 11:10:24 -0700 | [diff] [blame] | 751 | if (!p) |
| 752 | return NULL; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 753 | switch (p->token) { |
| 754 | case GREP_NOT: |
| 755 | if (!p->next) |
| 756 | die("--not not followed by pattern expression"); |
| 757 | *list = p->next; |
| 758 | x = xcalloc(1, sizeof (struct grep_expr)); |
| 759 | x->node = GREP_NODE_NOT; |
| 760 | x->u.unary = compile_pattern_not(list); |
| 761 | if (!x->u.unary) |
| 762 | die("--not followed by non pattern expression"); |
| 763 | return x; |
| 764 | default: |
| 765 | return compile_pattern_atom(list); |
| 766 | } |
| 767 | } |
| 768 | |
| 769 | static struct grep_expr *compile_pattern_and(struct grep_pat **list) |
| 770 | { |
| 771 | struct grep_pat *p; |
| 772 | struct grep_expr *x, *y, *z; |
| 773 | |
| 774 | x = compile_pattern_not(list); |
| 775 | p = *list; |
| 776 | if (p && p->token == GREP_AND) { |
| 777 | if (!p->next) |
| 778 | die("--and not followed by pattern expression"); |
| 779 | *list = p->next; |
| 780 | y = compile_pattern_and(list); |
| 781 | if (!y) |
| 782 | die("--and not followed by pattern expression"); |
| 783 | z = xcalloc(1, sizeof (struct grep_expr)); |
| 784 | z->node = GREP_NODE_AND; |
| 785 | z->u.binary.left = x; |
| 786 | z->u.binary.right = y; |
| 787 | return z; |
| 788 | } |
| 789 | return x; |
| 790 | } |
| 791 | |
| 792 | static struct grep_expr *compile_pattern_or(struct grep_pat **list) |
| 793 | { |
| 794 | struct grep_pat *p; |
| 795 | struct grep_expr *x, *y, *z; |
| 796 | |
| 797 | x = compile_pattern_and(list); |
| 798 | p = *list; |
| 799 | if (x && p && p->token != GREP_CLOSE_PAREN) { |
| 800 | y = compile_pattern_or(list); |
| 801 | if (!y) |
| 802 | die("not a pattern expression %s", p->pattern); |
| 803 | z = xcalloc(1, sizeof (struct grep_expr)); |
| 804 | z->node = GREP_NODE_OR; |
| 805 | z->u.binary.left = x; |
| 806 | z->u.binary.right = y; |
| 807 | return z; |
| 808 | } |
| 809 | return x; |
| 810 | } |
| 811 | |
| 812 | static struct grep_expr *compile_pattern_expr(struct grep_pat **list) |
| 813 | { |
| 814 | return compile_pattern_or(list); |
| 815 | } |
| 816 | |
Junio C Hamano | 17bf35a | 2012-09-13 14:21:44 -0700 | [diff] [blame] | 817 | static void indent(int in) |
| 818 | { |
| 819 | while (in-- > 0) |
| 820 | fputc(' ', stderr); |
| 821 | } |
| 822 | |
| 823 | static void dump_grep_pat(struct grep_pat *p) |
| 824 | { |
| 825 | switch (p->token) { |
| 826 | case GREP_AND: fprintf(stderr, "*and*"); break; |
| 827 | case GREP_OPEN_PAREN: fprintf(stderr, "*(*"); break; |
| 828 | case GREP_CLOSE_PAREN: fprintf(stderr, "*)*"); break; |
| 829 | case GREP_NOT: fprintf(stderr, "*not*"); break; |
| 830 | case GREP_OR: fprintf(stderr, "*or*"); break; |
| 831 | |
| 832 | case GREP_PATTERN: fprintf(stderr, "pattern"); break; |
| 833 | case GREP_PATTERN_HEAD: fprintf(stderr, "pattern_head"); break; |
| 834 | case GREP_PATTERN_BODY: fprintf(stderr, "pattern_body"); break; |
| 835 | } |
| 836 | |
| 837 | switch (p->token) { |
| 838 | default: break; |
| 839 | case GREP_PATTERN_HEAD: |
| 840 | fprintf(stderr, "<head %d>", p->field); break; |
| 841 | case GREP_PATTERN_BODY: |
| 842 | fprintf(stderr, "<body>"); break; |
| 843 | } |
| 844 | switch (p->token) { |
| 845 | default: break; |
| 846 | case GREP_PATTERN_HEAD: |
| 847 | case GREP_PATTERN_BODY: |
| 848 | case GREP_PATTERN: |
| 849 | fprintf(stderr, "%.*s", (int)p->patternlen, p->pattern); |
| 850 | break; |
| 851 | } |
| 852 | fputc('\n', stderr); |
| 853 | } |
| 854 | |
| 855 | static void dump_grep_expression_1(struct grep_expr *x, int in) |
| 856 | { |
| 857 | indent(in); |
| 858 | switch (x->node) { |
| 859 | case GREP_NODE_TRUE: |
| 860 | fprintf(stderr, "true\n"); |
| 861 | break; |
| 862 | case GREP_NODE_ATOM: |
| 863 | dump_grep_pat(x->u.atom); |
| 864 | break; |
| 865 | case GREP_NODE_NOT: |
| 866 | fprintf(stderr, "(not\n"); |
| 867 | dump_grep_expression_1(x->u.unary, in+1); |
| 868 | indent(in); |
| 869 | fprintf(stderr, ")\n"); |
| 870 | break; |
| 871 | case GREP_NODE_AND: |
| 872 | fprintf(stderr, "(and\n"); |
| 873 | dump_grep_expression_1(x->u.binary.left, in+1); |
| 874 | dump_grep_expression_1(x->u.binary.right, in+1); |
| 875 | indent(in); |
| 876 | fprintf(stderr, ")\n"); |
| 877 | break; |
| 878 | case GREP_NODE_OR: |
| 879 | fprintf(stderr, "(or\n"); |
| 880 | dump_grep_expression_1(x->u.binary.left, in+1); |
| 881 | dump_grep_expression_1(x->u.binary.right, in+1); |
| 882 | indent(in); |
| 883 | fprintf(stderr, ")\n"); |
| 884 | break; |
| 885 | } |
| 886 | } |
| 887 | |
Junio C Hamano | 07a7d65 | 2012-09-15 14:04:36 -0700 | [diff] [blame] | 888 | static void dump_grep_expression(struct grep_opt *opt) |
Junio C Hamano | 17bf35a | 2012-09-13 14:21:44 -0700 | [diff] [blame] | 889 | { |
| 890 | struct grep_expr *x = opt->pattern_expression; |
| 891 | |
| 892 | if (opt->all_match) |
| 893 | fprintf(stderr, "[all-match]\n"); |
| 894 | dump_grep_expression_1(x, 0); |
| 895 | fflush(NULL); |
| 896 | } |
| 897 | |
Junio C Hamano | 5aaeb73 | 2010-09-12 22:15:35 -0700 | [diff] [blame] | 898 | static struct grep_expr *grep_true_expr(void) |
| 899 | { |
| 900 | struct grep_expr *z = xcalloc(1, sizeof(*z)); |
| 901 | z->node = GREP_NODE_TRUE; |
| 902 | return z; |
| 903 | } |
| 904 | |
| 905 | static struct grep_expr *grep_or_expr(struct grep_expr *left, struct grep_expr *right) |
| 906 | { |
| 907 | struct grep_expr *z = xcalloc(1, sizeof(*z)); |
| 908 | z->node = GREP_NODE_OR; |
| 909 | z->u.binary.left = left; |
| 910 | z->u.binary.right = right; |
| 911 | return z; |
| 912 | } |
| 913 | |
Junio C Hamano | 95ce9ce | 2010-09-12 19:30:48 -0700 | [diff] [blame] | 914 | static struct grep_expr *prep_header_patterns(struct grep_opt *opt) |
| 915 | { |
| 916 | struct grep_pat *p; |
| 917 | struct grep_expr *header_expr; |
Junio C Hamano | 5aaeb73 | 2010-09-12 22:15:35 -0700 | [diff] [blame] | 918 | struct grep_expr *(header_group[GREP_HEADER_FIELD_MAX]); |
| 919 | enum grep_header_field fld; |
Junio C Hamano | 95ce9ce | 2010-09-12 19:30:48 -0700 | [diff] [blame] | 920 | |
| 921 | if (!opt->header_list) |
| 922 | return NULL; |
Angus Hammond | 2385f24 | 2012-05-06 19:17:15 +0100 | [diff] [blame] | 923 | |
Junio C Hamano | 95ce9ce | 2010-09-12 19:30:48 -0700 | [diff] [blame] | 924 | for (p = opt->header_list; p; p = p->next) { |
| 925 | if (p->token != GREP_PATTERN_HEAD) |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 926 | BUG("a non-header pattern in grep header list."); |
Antoine Pelisse | 3ce3ffb | 2013-02-03 14:37:09 +0000 | [diff] [blame] | 927 | if (p->field < GREP_HEADER_FIELD_MIN || |
| 928 | GREP_HEADER_FIELD_MAX <= p->field) |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 929 | BUG("unknown header field %d", p->field); |
Junio C Hamano | 95ce9ce | 2010-09-12 19:30:48 -0700 | [diff] [blame] | 930 | compile_regexp(p, opt); |
| 931 | } |
Junio C Hamano | 5aaeb73 | 2010-09-12 22:15:35 -0700 | [diff] [blame] | 932 | |
| 933 | for (fld = 0; fld < GREP_HEADER_FIELD_MAX; fld++) |
| 934 | header_group[fld] = NULL; |
| 935 | |
| 936 | for (p = opt->header_list; p; p = p->next) { |
| 937 | struct grep_expr *h; |
| 938 | struct grep_pat *pp = p; |
| 939 | |
| 940 | h = compile_pattern_atom(&pp); |
| 941 | if (!h || pp != p->next) |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 942 | BUG("malformed header expr"); |
Junio C Hamano | 5aaeb73 | 2010-09-12 22:15:35 -0700 | [diff] [blame] | 943 | if (!header_group[p->field]) { |
| 944 | header_group[p->field] = h; |
| 945 | continue; |
| 946 | } |
| 947 | header_group[p->field] = grep_or_expr(h, header_group[p->field]); |
| 948 | } |
| 949 | |
| 950 | header_expr = NULL; |
| 951 | |
| 952 | for (fld = 0; fld < GREP_HEADER_FIELD_MAX; fld++) { |
| 953 | if (!header_group[fld]) |
| 954 | continue; |
| 955 | if (!header_expr) |
| 956 | header_expr = grep_true_expr(); |
| 957 | header_expr = grep_or_expr(header_group[fld], header_expr); |
| 958 | } |
Junio C Hamano | 95ce9ce | 2010-09-12 19:30:48 -0700 | [diff] [blame] | 959 | return header_expr; |
| 960 | } |
| 961 | |
Junio C Hamano | 13e4fc7 | 2012-09-13 16:26:57 -0700 | [diff] [blame] | 962 | static struct grep_expr *grep_splice_or(struct grep_expr *x, struct grep_expr *y) |
| 963 | { |
| 964 | struct grep_expr *z = x; |
| 965 | |
| 966 | while (x) { |
| 967 | assert(x->node == GREP_NODE_OR); |
| 968 | if (x->u.binary.right && |
| 969 | x->u.binary.right->node == GREP_NODE_TRUE) { |
| 970 | x->u.binary.right = y; |
| 971 | break; |
| 972 | } |
| 973 | x = x->u.binary.right; |
| 974 | } |
| 975 | return z; |
| 976 | } |
| 977 | |
Junio C Hamano | 17bf35a | 2012-09-13 14:21:44 -0700 | [diff] [blame] | 978 | static void compile_grep_patterns_real(struct grep_opt *opt) |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 979 | { |
| 980 | struct grep_pat *p; |
Junio C Hamano | 95ce9ce | 2010-09-12 19:30:48 -0700 | [diff] [blame] | 981 | struct grep_expr *header_expr = prep_header_patterns(opt); |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 982 | |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 983 | for (p = opt->pattern_list; p; p = p->next) { |
Junio C Hamano | 480c1ca | 2006-09-20 12:39:46 -0700 | [diff] [blame] | 984 | switch (p->token) { |
| 985 | case GREP_PATTERN: /* atom */ |
| 986 | case GREP_PATTERN_HEAD: |
| 987 | case GREP_PATTERN_BODY: |
René Scharfe | c822255 | 2009-01-10 00:18:34 +0100 | [diff] [blame] | 988 | compile_regexp(p, opt); |
Junio C Hamano | 480c1ca | 2006-09-20 12:39:46 -0700 | [diff] [blame] | 989 | break; |
| 990 | default: |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 991 | opt->extended = 1; |
Junio C Hamano | 480c1ca | 2006-09-20 12:39:46 -0700 | [diff] [blame] | 992 | break; |
| 993 | } |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 994 | } |
| 995 | |
Junio C Hamano | 80235ba | 2010-01-17 20:09:06 -0800 | [diff] [blame] | 996 | if (opt->all_match || header_expr) |
| 997 | opt->extended = 1; |
Junio C Hamano | 17bf35a | 2012-09-13 14:21:44 -0700 | [diff] [blame] | 998 | else if (!opt->extended && !opt->debug) |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 999 | return; |
| 1000 | |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1001 | p = opt->pattern_list; |
Michele Ballabio | ba150a3 | 2009-03-18 21:53:27 +0100 | [diff] [blame] | 1002 | if (p) |
| 1003 | opt->pattern_expression = compile_pattern_expr(&p); |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1004 | if (p) |
| 1005 | die("incomplete pattern expression: %s", p->pattern); |
Junio C Hamano | 80235ba | 2010-01-17 20:09:06 -0800 | [diff] [blame] | 1006 | |
| 1007 | if (!header_expr) |
| 1008 | return; |
| 1009 | |
Junio C Hamano | 5aaeb73 | 2010-09-12 22:15:35 -0700 | [diff] [blame] | 1010 | if (!opt->pattern_expression) |
Junio C Hamano | 80235ba | 2010-01-17 20:09:06 -0800 | [diff] [blame] | 1011 | opt->pattern_expression = header_expr; |
Junio C Hamano | 13e4fc7 | 2012-09-13 16:26:57 -0700 | [diff] [blame] | 1012 | else if (opt->all_match) |
| 1013 | opt->pattern_expression = grep_splice_or(header_expr, |
| 1014 | opt->pattern_expression); |
Junio C Hamano | 5aaeb73 | 2010-09-12 22:15:35 -0700 | [diff] [blame] | 1015 | else |
| 1016 | opt->pattern_expression = grep_or_expr(opt->pattern_expression, |
| 1017 | header_expr); |
Junio C Hamano | 80235ba | 2010-01-17 20:09:06 -0800 | [diff] [blame] | 1018 | opt->all_match = 1; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1019 | } |
| 1020 | |
Junio C Hamano | 17bf35a | 2012-09-13 14:21:44 -0700 | [diff] [blame] | 1021 | void compile_grep_patterns(struct grep_opt *opt) |
| 1022 | { |
| 1023 | compile_grep_patterns_real(opt); |
| 1024 | if (opt->debug) |
| 1025 | dump_grep_expression(opt); |
| 1026 | } |
| 1027 | |
Junio C Hamano | b48fb5b | 2006-09-27 16:27:10 -0700 | [diff] [blame] | 1028 | static void free_pattern_expr(struct grep_expr *x) |
| 1029 | { |
| 1030 | switch (x->node) { |
Junio C Hamano | 5aaeb73 | 2010-09-12 22:15:35 -0700 | [diff] [blame] | 1031 | case GREP_NODE_TRUE: |
Junio C Hamano | b48fb5b | 2006-09-27 16:27:10 -0700 | [diff] [blame] | 1032 | case GREP_NODE_ATOM: |
| 1033 | break; |
| 1034 | case GREP_NODE_NOT: |
| 1035 | free_pattern_expr(x->u.unary); |
| 1036 | break; |
| 1037 | case GREP_NODE_AND: |
| 1038 | case GREP_NODE_OR: |
| 1039 | free_pattern_expr(x->u.binary.left); |
| 1040 | free_pattern_expr(x->u.binary.right); |
| 1041 | break; |
| 1042 | } |
| 1043 | free(x); |
| 1044 | } |
| 1045 | |
| 1046 | void free_grep_patterns(struct grep_opt *opt) |
| 1047 | { |
| 1048 | struct grep_pat *p, *n; |
| 1049 | |
| 1050 | for (p = opt->pattern_list; p; p = n) { |
| 1051 | n = p->next; |
| 1052 | switch (p->token) { |
| 1053 | case GREP_PATTERN: /* atom */ |
| 1054 | case GREP_PATTERN_HEAD: |
| 1055 | case GREP_PATTERN_BODY: |
Fredrik Kuivinen | 9ecedde | 2011-08-21 00:42:18 +0200 | [diff] [blame] | 1056 | if (p->kws) |
| 1057 | kwsfree(p->kws); |
Ævar Arnfjörð Bjarmason | 6d4b574 | 2017-05-25 19:45:29 +0000 | [diff] [blame] | 1058 | else if (p->pcre1_regexp) |
| 1059 | free_pcre1_regexp(p); |
Ævar Arnfjörð Bjarmason | 94da919 | 2017-06-01 18:20:56 +0000 | [diff] [blame] | 1060 | else if (p->pcre2_pattern) |
| 1061 | free_pcre2_pattern(p); |
Michał Kiedrowicz | 63e7e9d | 2011-05-09 23:52:05 +0200 | [diff] [blame] | 1062 | else |
| 1063 | regfree(&p->regexp); |
René Scharfe | 526a858 | 2012-05-20 16:33:07 +0200 | [diff] [blame] | 1064 | free(p->pattern); |
Junio C Hamano | b48fb5b | 2006-09-27 16:27:10 -0700 | [diff] [blame] | 1065 | break; |
| 1066 | default: |
| 1067 | break; |
| 1068 | } |
| 1069 | free(p); |
| 1070 | } |
| 1071 | |
| 1072 | if (!opt->extended) |
| 1073 | return; |
| 1074 | free_pattern_expr(opt->pattern_expression); |
| 1075 | } |
| 1076 | |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1077 | static char *end_of_line(char *cp, unsigned long *left) |
| 1078 | { |
| 1079 | unsigned long l = *left; |
| 1080 | while (l && *cp != '\n') { |
| 1081 | l--; |
| 1082 | cp++; |
| 1083 | } |
| 1084 | *left = l; |
| 1085 | return cp; |
| 1086 | } |
| 1087 | |
| 1088 | static int word_char(char ch) |
| 1089 | { |
| 1090 | return isalnum(ch) || ch == '_'; |
| 1091 | } |
| 1092 | |
Mark Lodato | 55f638b | 2010-03-07 11:52:46 -0500 | [diff] [blame] | 1093 | static void output_color(struct grep_opt *opt, const void *data, size_t size, |
| 1094 | const char *color) |
| 1095 | { |
Jeff King | daa0c3d | 2011-08-17 22:04:23 -0700 | [diff] [blame] | 1096 | if (want_color(opt->color) && color && color[0]) { |
Mark Lodato | 55f638b | 2010-03-07 11:52:46 -0500 | [diff] [blame] | 1097 | opt->output(opt, color, strlen(color)); |
| 1098 | opt->output(opt, data, size); |
| 1099 | opt->output(opt, GIT_COLOR_RESET, strlen(GIT_COLOR_RESET)); |
| 1100 | } else |
| 1101 | opt->output(opt, data, size); |
| 1102 | } |
| 1103 | |
| 1104 | static void output_sep(struct grep_opt *opt, char sign) |
| 1105 | { |
| 1106 | if (opt->null_following_name) |
| 1107 | opt->output(opt, "\0", 1); |
| 1108 | else |
Nguyễn Thái Ngọc Duy | fa151dc | 2018-05-26 15:55:22 +0200 | [diff] [blame] | 1109 | output_color(opt, &sign, 1, opt->colors[GREP_COLOR_SEP]); |
Mark Lodato | 55f638b | 2010-03-07 11:52:46 -0500 | [diff] [blame] | 1110 | } |
| 1111 | |
Raphael Zimmerer | 83caecc | 2008-10-01 18:11:15 +0200 | [diff] [blame] | 1112 | static void show_name(struct grep_opt *opt, const char *name) |
| 1113 | { |
Nguyễn Thái Ngọc Duy | fa151dc | 2018-05-26 15:55:22 +0200 | [diff] [blame] | 1114 | output_color(opt, name, strlen(name), opt->colors[GREP_COLOR_FILENAME]); |
Fredrik Kuivinen | 5b594f4 | 2010-01-25 23:51:39 +0100 | [diff] [blame] | 1115 | opt->output(opt, opt->null_following_name ? "\0" : "\n", 1); |
Raphael Zimmerer | 83caecc | 2008-10-01 18:11:15 +0200 | [diff] [blame] | 1116 | } |
| 1117 | |
René Scharfe | ed40a09 | 2010-05-22 23:43:43 +0200 | [diff] [blame] | 1118 | static int fixmatch(struct grep_pat *p, char *line, char *eol, |
| 1119 | regmatch_t *match) |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1120 | { |
Fredrik Kuivinen | 9ecedde | 2011-08-21 00:42:18 +0200 | [diff] [blame] | 1121 | struct kwsmatch kwsm; |
| 1122 | size_t offset = kwsexec(p->kws, line, eol - line, &kwsm); |
| 1123 | if (offset == -1) { |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1124 | match->rm_so = match->rm_eo = -1; |
| 1125 | return REG_NOMATCH; |
Fredrik Kuivinen | 9ecedde | 2011-08-21 00:42:18 +0200 | [diff] [blame] | 1126 | } else { |
| 1127 | match->rm_so = offset; |
| 1128 | match->rm_eo = match->rm_so + kwsm.size[0]; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1129 | return 0; |
| 1130 | } |
| 1131 | } |
| 1132 | |
Michał Kiedrowicz | 97e7778 | 2011-05-05 00:00:19 +0200 | [diff] [blame] | 1133 | static int patmatch(struct grep_pat *p, char *line, char *eol, |
| 1134 | regmatch_t *match, int eflags) |
| 1135 | { |
| 1136 | int hit; |
| 1137 | |
| 1138 | if (p->fixed) |
| 1139 | hit = !fixmatch(p, line, eol, match); |
Ævar Arnfjörð Bjarmason | 6d4b574 | 2017-05-25 19:45:29 +0000 | [diff] [blame] | 1140 | else if (p->pcre1_regexp) |
| 1141 | hit = !pcre1match(p, line, eol, match, eflags); |
Ævar Arnfjörð Bjarmason | 94da919 | 2017-06-01 18:20:56 +0000 | [diff] [blame] | 1142 | else if (p->pcre2_pattern) |
| 1143 | hit = !pcre2match(p, line, eol, match, eflags); |
Michał Kiedrowicz | 97e7778 | 2011-05-05 00:00:19 +0200 | [diff] [blame] | 1144 | else |
Johannes Schindelin | b7d36ff | 2016-09-21 20:24:14 +0200 | [diff] [blame] | 1145 | hit = !regexec_buf(&p->regexp, line, eol - line, 1, match, |
| 1146 | eflags); |
Michał Kiedrowicz | 97e7778 | 2011-05-05 00:00:19 +0200 | [diff] [blame] | 1147 | |
| 1148 | return hit; |
| 1149 | } |
| 1150 | |
Junio C Hamano | a4d7d2c | 2008-09-04 22:15:02 -0700 | [diff] [blame] | 1151 | static int strip_timestamp(char *bol, char **eol_p) |
| 1152 | { |
| 1153 | char *eol = *eol_p; |
| 1154 | int ch; |
| 1155 | |
| 1156 | while (bol < --eol) { |
| 1157 | if (*eol != '>') |
| 1158 | continue; |
| 1159 | *eol_p = ++eol; |
| 1160 | ch = *eol; |
| 1161 | *eol = '\0'; |
| 1162 | return ch; |
| 1163 | } |
| 1164 | return 0; |
| 1165 | } |
| 1166 | |
| 1167 | static struct { |
| 1168 | const char *field; |
| 1169 | size_t len; |
| 1170 | } header_field[] = { |
| 1171 | { "author ", 7 }, |
| 1172 | { "committer ", 10 }, |
Nguyễn Thái Ngọc Duy | 72fd13f | 2012-09-29 11:41:28 +0700 | [diff] [blame] | 1173 | { "reflog ", 7 }, |
Junio C Hamano | a4d7d2c | 2008-09-04 22:15:02 -0700 | [diff] [blame] | 1174 | }; |
| 1175 | |
René Scharfe | d7eb527 | 2009-03-07 13:28:40 +0100 | [diff] [blame] | 1176 | static int match_one_pattern(struct grep_pat *p, char *bol, char *eol, |
René Scharfe | 7921277 | 2009-03-07 13:30:27 +0100 | [diff] [blame] | 1177 | enum grep_context ctx, |
| 1178 | regmatch_t *pmatch, int eflags) |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1179 | { |
| 1180 | int hit = 0; |
Junio C Hamano | a4d7d2c | 2008-09-04 22:15:02 -0700 | [diff] [blame] | 1181 | int saved_ch = 0; |
René Scharfe | e701fad | 2009-05-20 23:31:53 +0200 | [diff] [blame] | 1182 | const char *start = bol; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1183 | |
Junio C Hamano | 480c1ca | 2006-09-20 12:39:46 -0700 | [diff] [blame] | 1184 | if ((p->token != GREP_PATTERN) && |
| 1185 | ((p->token == GREP_PATTERN_HEAD) != (ctx == GREP_CONTEXT_HEAD))) |
| 1186 | return 0; |
| 1187 | |
Junio C Hamano | a4d7d2c | 2008-09-04 22:15:02 -0700 | [diff] [blame] | 1188 | if (p->token == GREP_PATTERN_HEAD) { |
| 1189 | const char *field; |
| 1190 | size_t len; |
| 1191 | assert(p->field < ARRAY_SIZE(header_field)); |
| 1192 | field = header_field[p->field].field; |
| 1193 | len = header_field[p->field].len; |
| 1194 | if (strncmp(bol, field, len)) |
| 1195 | return 0; |
| 1196 | bol += len; |
Nguyễn Thái Ngọc Duy | ad4813b | 2012-09-29 11:41:27 +0700 | [diff] [blame] | 1197 | switch (p->field) { |
| 1198 | case GREP_HEADER_AUTHOR: |
| 1199 | case GREP_HEADER_COMMITTER: |
| 1200 | saved_ch = strip_timestamp(bol, &eol); |
| 1201 | break; |
| 1202 | default: |
| 1203 | break; |
| 1204 | } |
Junio C Hamano | a4d7d2c | 2008-09-04 22:15:02 -0700 | [diff] [blame] | 1205 | } |
| 1206 | |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1207 | again: |
Michał Kiedrowicz | 97e7778 | 2011-05-05 00:00:19 +0200 | [diff] [blame] | 1208 | hit = patmatch(p, bol, eol, pmatch, eflags); |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1209 | |
René Scharfe | d7eb527 | 2009-03-07 13:28:40 +0100 | [diff] [blame] | 1210 | if (hit && p->word_regexp) { |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1211 | if ((pmatch[0].rm_so < 0) || |
René Scharfe | 84201ea | 2009-06-03 18:19:01 +0200 | [diff] [blame] | 1212 | (eol - bol) < pmatch[0].rm_so || |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1213 | (pmatch[0].rm_eo < 0) || |
| 1214 | (eol - bol) < pmatch[0].rm_eo) |
| 1215 | die("regexp returned nonsense"); |
| 1216 | |
| 1217 | /* Match beginning must be either beginning of the |
| 1218 | * line, or at word boundary (i.e. the last char must |
| 1219 | * not be a word char). Similarly, match end must be |
| 1220 | * either end of the line, or at word boundary |
| 1221 | * (i.e. the next char must not be a word char). |
| 1222 | */ |
René Scharfe | fb62eb7 | 2009-01-10 00:08:40 +0100 | [diff] [blame] | 1223 | if ( ((pmatch[0].rm_so == 0) || |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1224 | !word_char(bol[pmatch[0].rm_so-1])) && |
| 1225 | ((pmatch[0].rm_eo == (eol-bol)) || |
| 1226 | !word_char(bol[pmatch[0].rm_eo])) ) |
| 1227 | ; |
| 1228 | else |
| 1229 | hit = 0; |
| 1230 | |
René Scharfe | 84201ea | 2009-06-03 18:19:01 +0200 | [diff] [blame] | 1231 | /* Words consist of at least one character. */ |
| 1232 | if (pmatch->rm_so == pmatch->rm_eo) |
| 1233 | hit = 0; |
| 1234 | |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1235 | if (!hit && pmatch[0].rm_so + bol + 1 < eol) { |
| 1236 | /* There could be more than one match on the |
| 1237 | * line, and the first match might not be |
| 1238 | * strict word match. But later ones could be! |
René Scharfe | fb62eb7 | 2009-01-10 00:08:40 +0100 | [diff] [blame] | 1239 | * Forward to the next possible start, i.e. the |
| 1240 | * next position following a non-word char. |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1241 | */ |
| 1242 | bol = pmatch[0].rm_so + bol + 1; |
René Scharfe | fb62eb7 | 2009-01-10 00:08:40 +0100 | [diff] [blame] | 1243 | while (word_char(bol[-1]) && bol < eol) |
| 1244 | bol++; |
René Scharfe | dbb6a4a | 2009-05-23 13:45:26 +0200 | [diff] [blame] | 1245 | eflags |= REG_NOTBOL; |
René Scharfe | fb62eb7 | 2009-01-10 00:08:40 +0100 | [diff] [blame] | 1246 | if (bol < eol) |
| 1247 | goto again; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1248 | } |
| 1249 | } |
Junio C Hamano | a4d7d2c | 2008-09-04 22:15:02 -0700 | [diff] [blame] | 1250 | if (p->token == GREP_PATTERN_HEAD && saved_ch) |
| 1251 | *eol = saved_ch; |
René Scharfe | e701fad | 2009-05-20 23:31:53 +0200 | [diff] [blame] | 1252 | if (hit) { |
| 1253 | pmatch[0].rm_so += bol - start; |
| 1254 | pmatch[0].rm_eo += bol - start; |
| 1255 | } |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1256 | return hit; |
| 1257 | } |
| 1258 | |
Taylor Blau | 68d686e | 2018-06-22 10:49:35 -0500 | [diff] [blame] | 1259 | static int match_expr_eval(struct grep_opt *opt, struct grep_expr *x, char *bol, |
| 1260 | char *eol, enum grep_context ctx, ssize_t *col, |
| 1261 | ssize_t *icol, int collect_hits) |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1262 | { |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 1263 | int h = 0; |
| 1264 | |
Linus Torvalds | c922b01 | 2009-04-27 11:10:24 -0700 | [diff] [blame] | 1265 | if (!x) |
| 1266 | die("Not a valid grep expression"); |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1267 | switch (x->node) { |
Junio C Hamano | 5aaeb73 | 2010-09-12 22:15:35 -0700 | [diff] [blame] | 1268 | case GREP_NODE_TRUE: |
| 1269 | h = 1; |
| 1270 | break; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1271 | case GREP_NODE_ATOM: |
Taylor Blau | 68d686e | 2018-06-22 10:49:35 -0500 | [diff] [blame] | 1272 | { |
| 1273 | regmatch_t tmp; |
| 1274 | h = match_one_pattern(x->u.atom, bol, eol, ctx, |
| 1275 | &tmp, 0); |
| 1276 | if (h && (*col < 0 || tmp.rm_so < *col)) |
| 1277 | *col = tmp.rm_so; |
| 1278 | } |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1279 | break; |
| 1280 | case GREP_NODE_NOT: |
Taylor Blau | 68d686e | 2018-06-22 10:49:35 -0500 | [diff] [blame] | 1281 | /* |
| 1282 | * Upon visiting a GREP_NODE_NOT, col and icol become swapped. |
| 1283 | */ |
| 1284 | h = !match_expr_eval(opt, x->u.unary, bol, eol, ctx, icol, col, |
| 1285 | 0); |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 1286 | break; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1287 | case GREP_NODE_AND: |
Taylor Blau | 017c0fc | 2018-06-22 10:49:39 -0500 | [diff] [blame] | 1288 | h = match_expr_eval(opt, x->u.binary.left, bol, eol, ctx, col, |
Taylor Blau | 68d686e | 2018-06-22 10:49:35 -0500 | [diff] [blame] | 1289 | icol, 0); |
Taylor Blau | 017c0fc | 2018-06-22 10:49:39 -0500 | [diff] [blame] | 1290 | if (h || opt->columnnum) { |
| 1291 | /* |
| 1292 | * Don't short-circuit AND when given --column, since a |
| 1293 | * NOT earlier in the tree may turn this into an OR. In |
| 1294 | * this case, see the below comment. |
| 1295 | */ |
| 1296 | h &= match_expr_eval(opt, x->u.binary.right, bol, eol, |
| 1297 | ctx, col, icol, 0); |
| 1298 | } |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 1299 | break; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1300 | case GREP_NODE_OR: |
Taylor Blau | 017c0fc | 2018-06-22 10:49:39 -0500 | [diff] [blame] | 1301 | if (!(collect_hits || opt->columnnum)) { |
| 1302 | /* |
| 1303 | * Don't short-circuit OR when given --column (or |
| 1304 | * collecting hits) to ensure we don't skip a later |
| 1305 | * child that would produce an earlier match. |
| 1306 | */ |
Taylor Blau | 68d686e | 2018-06-22 10:49:35 -0500 | [diff] [blame] | 1307 | return (match_expr_eval(opt, x->u.binary.left, bol, eol, |
| 1308 | ctx, col, icol, 0) || |
| 1309 | match_expr_eval(opt, x->u.binary.right, bol, |
| 1310 | eol, ctx, col, icol, 0)); |
Taylor Blau | 017c0fc | 2018-06-22 10:49:39 -0500 | [diff] [blame] | 1311 | } |
Taylor Blau | 68d686e | 2018-06-22 10:49:35 -0500 | [diff] [blame] | 1312 | h = match_expr_eval(opt, x->u.binary.left, bol, eol, ctx, col, |
| 1313 | icol, 0); |
Taylor Blau | 017c0fc | 2018-06-22 10:49:39 -0500 | [diff] [blame] | 1314 | if (collect_hits) |
| 1315 | x->u.binary.left->hit |= h; |
Taylor Blau | 68d686e | 2018-06-22 10:49:35 -0500 | [diff] [blame] | 1316 | h |= match_expr_eval(opt, x->u.binary.right, bol, eol, ctx, col, |
Taylor Blau | 017c0fc | 2018-06-22 10:49:39 -0500 | [diff] [blame] | 1317 | icol, collect_hits); |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 1318 | break; |
| 1319 | default: |
Alexander Potashev | d753070 | 2009-01-04 21:38:41 +0300 | [diff] [blame] | 1320 | die("Unexpected node type (internal error) %d", x->node); |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1321 | } |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 1322 | if (collect_hits) |
| 1323 | x->hit |= h; |
| 1324 | return h; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1325 | } |
| 1326 | |
Junio C Hamano | 480c1ca | 2006-09-20 12:39:46 -0700 | [diff] [blame] | 1327 | static int match_expr(struct grep_opt *opt, char *bol, char *eol, |
Taylor Blau | 68d686e | 2018-06-22 10:49:35 -0500 | [diff] [blame] | 1328 | enum grep_context ctx, ssize_t *col, |
| 1329 | ssize_t *icol, int collect_hits) |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1330 | { |
| 1331 | struct grep_expr *x = opt->pattern_expression; |
Taylor Blau | 68d686e | 2018-06-22 10:49:35 -0500 | [diff] [blame] | 1332 | return match_expr_eval(opt, x, bol, eol, ctx, col, icol, collect_hits); |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1333 | } |
| 1334 | |
Junio C Hamano | 480c1ca | 2006-09-20 12:39:46 -0700 | [diff] [blame] | 1335 | static int match_line(struct grep_opt *opt, char *bol, char *eol, |
Taylor Blau | 68d686e | 2018-06-22 10:49:35 -0500 | [diff] [blame] | 1336 | ssize_t *col, ssize_t *icol, |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 1337 | enum grep_context ctx, int collect_hits) |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1338 | { |
| 1339 | struct grep_pat *p; |
Taylor Blau | 017c0fc | 2018-06-22 10:49:39 -0500 | [diff] [blame] | 1340 | int hit = 0; |
René Scharfe | 7921277 | 2009-03-07 13:30:27 +0100 | [diff] [blame] | 1341 | |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1342 | if (opt->extended) |
Taylor Blau | 68d686e | 2018-06-22 10:49:35 -0500 | [diff] [blame] | 1343 | return match_expr(opt, bol, eol, ctx, col, icol, |
| 1344 | collect_hits); |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 1345 | |
| 1346 | /* we do not call with collect_hits without being extended */ |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1347 | for (p = opt->pattern_list; p; p = p->next) { |
Taylor Blau | 68d686e | 2018-06-22 10:49:35 -0500 | [diff] [blame] | 1348 | regmatch_t tmp; |
| 1349 | if (match_one_pattern(p, bol, eol, ctx, &tmp, 0)) { |
Taylor Blau | 017c0fc | 2018-06-22 10:49:39 -0500 | [diff] [blame] | 1350 | hit |= 1; |
| 1351 | if (!opt->columnnum) { |
| 1352 | /* |
| 1353 | * Without --column, any single match on a line |
| 1354 | * is enough to know that it needs to be |
| 1355 | * printed. With --column, scan _all_ patterns |
| 1356 | * to find the earliest. |
| 1357 | */ |
| 1358 | break; |
| 1359 | } |
| 1360 | if (*col < 0 || tmp.rm_so < *col) |
| 1361 | *col = tmp.rm_so; |
Taylor Blau | 68d686e | 2018-06-22 10:49:35 -0500 | [diff] [blame] | 1362 | } |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1363 | } |
Taylor Blau | 017c0fc | 2018-06-22 10:49:39 -0500 | [diff] [blame] | 1364 | return hit; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1365 | } |
| 1366 | |
René Scharfe | 7e8f59d | 2009-03-07 13:32:32 +0100 | [diff] [blame] | 1367 | static int match_next_pattern(struct grep_pat *p, char *bol, char *eol, |
| 1368 | enum grep_context ctx, |
| 1369 | regmatch_t *pmatch, int eflags) |
| 1370 | { |
| 1371 | regmatch_t match; |
| 1372 | |
| 1373 | if (!match_one_pattern(p, bol, eol, ctx, &match, eflags)) |
| 1374 | return 0; |
| 1375 | if (match.rm_so < 0 || match.rm_eo < 0) |
| 1376 | return 0; |
| 1377 | if (pmatch->rm_so >= 0 && pmatch->rm_eo >= 0) { |
| 1378 | if (match.rm_so > pmatch->rm_so) |
| 1379 | return 1; |
| 1380 | if (match.rm_so == pmatch->rm_so && match.rm_eo < pmatch->rm_eo) |
| 1381 | return 1; |
| 1382 | } |
| 1383 | pmatch->rm_so = match.rm_so; |
| 1384 | pmatch->rm_eo = match.rm_eo; |
| 1385 | return 1; |
| 1386 | } |
| 1387 | |
| 1388 | static int next_match(struct grep_opt *opt, char *bol, char *eol, |
| 1389 | enum grep_context ctx, regmatch_t *pmatch, int eflags) |
| 1390 | { |
| 1391 | struct grep_pat *p; |
| 1392 | int hit = 0; |
| 1393 | |
| 1394 | pmatch->rm_so = pmatch->rm_eo = -1; |
| 1395 | if (bol < eol) { |
| 1396 | for (p = opt->pattern_list; p; p = p->next) { |
| 1397 | switch (p->token) { |
| 1398 | case GREP_PATTERN: /* atom */ |
| 1399 | case GREP_PATTERN_HEAD: |
| 1400 | case GREP_PATTERN_BODY: |
| 1401 | hit |= match_next_pattern(p, bol, eol, ctx, |
| 1402 | pmatch, eflags); |
| 1403 | break; |
| 1404 | default: |
| 1405 | break; |
| 1406 | } |
| 1407 | } |
| 1408 | } |
| 1409 | return hit; |
| 1410 | } |
| 1411 | |
Taylor Blau | c707ded | 2018-07-03 16:51:56 -0500 | [diff] [blame] | 1412 | static void show_line_header(struct grep_opt *opt, const char *name, |
| 1413 | unsigned lno, ssize_t cno, char sign) |
René Scharfe | 7e8f59d | 2009-03-07 13:32:32 +0100 | [diff] [blame] | 1414 | { |
René Scharfe | 1d84f72 | 2011-06-05 17:24:36 +0200 | [diff] [blame] | 1415 | if (opt->heading && opt->last_shown == 0) { |
Nguyễn Thái Ngọc Duy | fa151dc | 2018-05-26 15:55:22 +0200 | [diff] [blame] | 1416 | output_color(opt, name, strlen(name), opt->colors[GREP_COLOR_FILENAME]); |
René Scharfe | 1d84f72 | 2011-06-05 17:24:36 +0200 | [diff] [blame] | 1417 | opt->output(opt, "\n", 1); |
| 1418 | } |
René Scharfe | 5dd06d3 | 2009-07-02 00:02:38 +0200 | [diff] [blame] | 1419 | opt->last_shown = lno; |
| 1420 | |
René Scharfe | 1d84f72 | 2011-06-05 17:24:36 +0200 | [diff] [blame] | 1421 | if (!opt->heading && opt->pathname) { |
Nguyễn Thái Ngọc Duy | fa151dc | 2018-05-26 15:55:22 +0200 | [diff] [blame] | 1422 | output_color(opt, name, strlen(name), opt->colors[GREP_COLOR_FILENAME]); |
Mark Lodato | 55f638b | 2010-03-07 11:52:46 -0500 | [diff] [blame] | 1423 | output_sep(opt, sign); |
Fredrik Kuivinen | 5b594f4 | 2010-01-25 23:51:39 +0100 | [diff] [blame] | 1424 | } |
| 1425 | if (opt->linenum) { |
| 1426 | char buf[32]; |
Jeff King | 1a168e5 | 2017-03-28 15:46:56 -0400 | [diff] [blame] | 1427 | xsnprintf(buf, sizeof(buf), "%d", lno); |
Nguyễn Thái Ngọc Duy | fa151dc | 2018-05-26 15:55:22 +0200 | [diff] [blame] | 1428 | output_color(opt, buf, strlen(buf), opt->colors[GREP_COLOR_LINENO]); |
Mark Lodato | 55f638b | 2010-03-07 11:52:46 -0500 | [diff] [blame] | 1429 | output_sep(opt, sign); |
Fredrik Kuivinen | 5b594f4 | 2010-01-25 23:51:39 +0100 | [diff] [blame] | 1430 | } |
Taylor Blau | 89252cd | 2018-06-22 10:49:42 -0500 | [diff] [blame] | 1431 | /* |
| 1432 | * Treat 'cno' as the 1-indexed offset from the start of a non-context |
| 1433 | * line to its first match. Otherwise, 'cno' is 0 indicating that we are |
| 1434 | * being called with a context line. |
| 1435 | */ |
| 1436 | if (opt->columnnum && cno) { |
| 1437 | char buf[32]; |
| 1438 | xsnprintf(buf, sizeof(buf), "%"PRIuMAX, (uintmax_t)cno); |
Junio C Hamano | d036d66 | 2018-07-18 12:20:31 -0700 | [diff] [blame] | 1439 | output_color(opt, buf, strlen(buf), opt->colors[GREP_COLOR_COLUMNNO]); |
Taylor Blau | 89252cd | 2018-06-22 10:49:42 -0500 | [diff] [blame] | 1440 | output_sep(opt, sign); |
| 1441 | } |
Taylor Blau | c707ded | 2018-07-03 16:51:56 -0500 | [diff] [blame] | 1442 | } |
| 1443 | |
| 1444 | static void show_line(struct grep_opt *opt, char *bol, char *eol, |
| 1445 | const char *name, unsigned lno, ssize_t cno, char sign) |
| 1446 | { |
| 1447 | int rest = eol - bol; |
Taylor Blau | 9d8db06 | 2018-07-09 15:33:47 -0500 | [diff] [blame] | 1448 | const char *match_color = NULL; |
| 1449 | const char *line_color = NULL; |
Taylor Blau | c707ded | 2018-07-03 16:51:56 -0500 | [diff] [blame] | 1450 | |
| 1451 | if (opt->file_break && opt->last_shown == 0) { |
| 1452 | if (opt->show_hunk_mark) |
| 1453 | opt->output(opt, "\n", 1); |
| 1454 | } else if (opt->pre_context || opt->post_context || opt->funcbody) { |
| 1455 | if (opt->last_shown == 0) { |
| 1456 | if (opt->show_hunk_mark) { |
Junio C Hamano | 87ece7c | 2018-08-02 15:30:44 -0700 | [diff] [blame] | 1457 | output_color(opt, "--", 2, opt->colors[GREP_COLOR_SEP]); |
Taylor Blau | c707ded | 2018-07-03 16:51:56 -0500 | [diff] [blame] | 1458 | opt->output(opt, "\n", 1); |
| 1459 | } |
| 1460 | } else if (lno > opt->last_shown + 1) { |
Junio C Hamano | 87ece7c | 2018-08-02 15:30:44 -0700 | [diff] [blame] | 1461 | output_color(opt, "--", 2, opt->colors[GREP_COLOR_SEP]); |
Taylor Blau | c707ded | 2018-07-03 16:51:56 -0500 | [diff] [blame] | 1462 | opt->output(opt, "\n", 1); |
| 1463 | } |
| 1464 | } |
Taylor Blau | 9d8db06 | 2018-07-09 15:33:47 -0500 | [diff] [blame] | 1465 | if (!opt->only_matching) { |
| 1466 | /* |
| 1467 | * In case the line we're being called with contains more than |
| 1468 | * one match, leave printing each header to the loop below. |
| 1469 | */ |
| 1470 | show_line_header(opt, name, lno, cno, sign); |
| 1471 | } |
| 1472 | if (opt->color || opt->only_matching) { |
René Scharfe | 7e8f59d | 2009-03-07 13:32:32 +0100 | [diff] [blame] | 1473 | regmatch_t match; |
| 1474 | enum grep_context ctx = GREP_CONTEXT_BODY; |
| 1475 | int ch = *eol; |
| 1476 | int eflags = 0; |
| 1477 | |
Taylor Blau | 9d8db06 | 2018-07-09 15:33:47 -0500 | [diff] [blame] | 1478 | if (opt->color) { |
| 1479 | if (sign == ':') |
Junio C Hamano | 87ece7c | 2018-08-02 15:30:44 -0700 | [diff] [blame] | 1480 | match_color = opt->colors[GREP_COLOR_MATCH_SELECTED]; |
Taylor Blau | 9d8db06 | 2018-07-09 15:33:47 -0500 | [diff] [blame] | 1481 | else |
Junio C Hamano | 87ece7c | 2018-08-02 15:30:44 -0700 | [diff] [blame] | 1482 | match_color = opt->colors[GREP_COLOR_MATCH_CONTEXT]; |
Taylor Blau | 9d8db06 | 2018-07-09 15:33:47 -0500 | [diff] [blame] | 1483 | if (sign == ':') |
Junio C Hamano | 87ece7c | 2018-08-02 15:30:44 -0700 | [diff] [blame] | 1484 | line_color = opt->colors[GREP_COLOR_SELECTED]; |
Taylor Blau | 9d8db06 | 2018-07-09 15:33:47 -0500 | [diff] [blame] | 1485 | else if (sign == '-') |
Junio C Hamano | 87ece7c | 2018-08-02 15:30:44 -0700 | [diff] [blame] | 1486 | line_color = opt->colors[GREP_COLOR_CONTEXT]; |
Taylor Blau | 9d8db06 | 2018-07-09 15:33:47 -0500 | [diff] [blame] | 1487 | else if (sign == '=') |
Junio C Hamano | 87ece7c | 2018-08-02 15:30:44 -0700 | [diff] [blame] | 1488 | line_color = opt->colors[GREP_COLOR_FUNCTION]; |
Taylor Blau | 9d8db06 | 2018-07-09 15:33:47 -0500 | [diff] [blame] | 1489 | } |
René Scharfe | 7e8f59d | 2009-03-07 13:32:32 +0100 | [diff] [blame] | 1490 | *eol = '\0'; |
| 1491 | while (next_match(opt, bol, eol, ctx, &match, eflags)) { |
René Scharfe | 1f5b9cc | 2009-06-01 23:53:05 +0200 | [diff] [blame] | 1492 | if (match.rm_so == match.rm_eo) |
| 1493 | break; |
Fredrik Kuivinen | 5b594f4 | 2010-01-25 23:51:39 +0100 | [diff] [blame] | 1494 | |
Taylor Blau | 9d8db06 | 2018-07-09 15:33:47 -0500 | [diff] [blame] | 1495 | if (opt->only_matching) |
| 1496 | show_line_header(opt, name, lno, cno, sign); |
| 1497 | else |
| 1498 | output_color(opt, bol, match.rm_so, line_color); |
Mark Lodato | 55f638b | 2010-03-07 11:52:46 -0500 | [diff] [blame] | 1499 | output_color(opt, bol + match.rm_so, |
René Scharfe | 79a7710 | 2014-10-27 19:23:05 +0100 | [diff] [blame] | 1500 | match.rm_eo - match.rm_so, match_color); |
Taylor Blau | 9d8db06 | 2018-07-09 15:33:47 -0500 | [diff] [blame] | 1501 | if (opt->only_matching) |
| 1502 | opt->output(opt, "\n", 1); |
René Scharfe | 7e8f59d | 2009-03-07 13:32:32 +0100 | [diff] [blame] | 1503 | bol += match.rm_eo; |
Taylor Blau | 9d8db06 | 2018-07-09 15:33:47 -0500 | [diff] [blame] | 1504 | cno += match.rm_eo; |
René Scharfe | 7e8f59d | 2009-03-07 13:32:32 +0100 | [diff] [blame] | 1505 | rest -= match.rm_eo; |
| 1506 | eflags = REG_NOTBOL; |
| 1507 | } |
| 1508 | *eol = ch; |
| 1509 | } |
Taylor Blau | 9d8db06 | 2018-07-09 15:33:47 -0500 | [diff] [blame] | 1510 | if (!opt->only_matching) { |
| 1511 | output_color(opt, bol, rest, line_color); |
| 1512 | opt->output(opt, "\n", 1); |
| 1513 | } |
René Scharfe | 7e8f59d | 2009-03-07 13:32:32 +0100 | [diff] [blame] | 1514 | } |
| 1515 | |
Thomas Rast | 0579f91 | 2011-12-12 22:16:07 +0100 | [diff] [blame] | 1516 | #ifndef NO_PTHREADS |
Jeff King | 78db6ea | 2012-02-02 03:18:29 -0500 | [diff] [blame] | 1517 | int grep_use_locks; |
| 1518 | |
Thomas Rast | 0579f91 | 2011-12-12 22:16:07 +0100 | [diff] [blame] | 1519 | /* |
| 1520 | * This lock protects access to the gitattributes machinery, which is |
| 1521 | * not thread-safe. |
| 1522 | */ |
| 1523 | pthread_mutex_t grep_attr_mutex; |
| 1524 | |
Jeff King | 78db6ea | 2012-02-02 03:18:29 -0500 | [diff] [blame] | 1525 | static inline void grep_attr_lock(void) |
Thomas Rast | 0579f91 | 2011-12-12 22:16:07 +0100 | [diff] [blame] | 1526 | { |
Jeff King | 78db6ea | 2012-02-02 03:18:29 -0500 | [diff] [blame] | 1527 | if (grep_use_locks) |
Thomas Rast | 0579f91 | 2011-12-12 22:16:07 +0100 | [diff] [blame] | 1528 | pthread_mutex_lock(&grep_attr_mutex); |
| 1529 | } |
| 1530 | |
Jeff King | 78db6ea | 2012-02-02 03:18:29 -0500 | [diff] [blame] | 1531 | static inline void grep_attr_unlock(void) |
Thomas Rast | 0579f91 | 2011-12-12 22:16:07 +0100 | [diff] [blame] | 1532 | { |
Jeff King | 78db6ea | 2012-02-02 03:18:29 -0500 | [diff] [blame] | 1533 | if (grep_use_locks) |
Thomas Rast | 0579f91 | 2011-12-12 22:16:07 +0100 | [diff] [blame] | 1534 | pthread_mutex_unlock(&grep_attr_mutex); |
| 1535 | } |
Jeff King | b3aeb28 | 2012-02-02 03:18:41 -0500 | [diff] [blame] | 1536 | |
| 1537 | /* |
| 1538 | * Same as git_attr_mutex, but protecting the thread-unsafe object db access. |
| 1539 | */ |
| 1540 | pthread_mutex_t grep_read_mutex; |
| 1541 | |
Thomas Rast | 0579f91 | 2011-12-12 22:16:07 +0100 | [diff] [blame] | 1542 | #else |
Jeff King | 78db6ea | 2012-02-02 03:18:29 -0500 | [diff] [blame] | 1543 | #define grep_attr_lock() |
| 1544 | #define grep_attr_unlock() |
Thomas Rast | 0579f91 | 2011-12-12 22:16:07 +0100 | [diff] [blame] | 1545 | #endif |
| 1546 | |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1547 | static int match_funcname(struct grep_opt *opt, struct grep_source *gs, char *bol, char *eol) |
René Scharfe | 2944e4e | 2009-07-02 00:06:34 +0200 | [diff] [blame] | 1548 | { |
René Scharfe | 60ecac9 | 2009-07-02 00:07:24 +0200 | [diff] [blame] | 1549 | xdemitconf_t *xecfg = opt->priv; |
Thomas Rast | 0579f91 | 2011-12-12 22:16:07 +0100 | [diff] [blame] | 1550 | if (xecfg && !xecfg->find_func) { |
Nguyễn Thái Ngọc Duy | acd00ea | 2018-09-21 17:57:33 +0200 | [diff] [blame] | 1551 | grep_source_load_driver(gs, opt->repo->index); |
Jeff King | 94ad9d9 | 2012-02-02 03:20:43 -0500 | [diff] [blame] | 1552 | if (gs->driver->funcname.pattern) { |
| 1553 | const struct userdiff_funcname *pe = &gs->driver->funcname; |
Thomas Rast | 0579f91 | 2011-12-12 22:16:07 +0100 | [diff] [blame] | 1554 | xdiff_set_find_func(xecfg, pe->pattern, pe->cflags); |
| 1555 | } else { |
| 1556 | xecfg = opt->priv = NULL; |
| 1557 | } |
| 1558 | } |
| 1559 | |
| 1560 | if (xecfg) { |
René Scharfe | 60ecac9 | 2009-07-02 00:07:24 +0200 | [diff] [blame] | 1561 | char buf[1]; |
| 1562 | return xecfg->find_func(bol, eol - bol, buf, 1, |
| 1563 | xecfg->find_func_priv) >= 0; |
| 1564 | } |
| 1565 | |
René Scharfe | 2944e4e | 2009-07-02 00:06:34 +0200 | [diff] [blame] | 1566 | if (bol == eol) |
| 1567 | return 0; |
| 1568 | if (isalpha(*bol) || *bol == '_' || *bol == '$') |
| 1569 | return 1; |
| 1570 | return 0; |
| 1571 | } |
| 1572 | |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1573 | static void show_funcname_line(struct grep_opt *opt, struct grep_source *gs, |
| 1574 | char *bol, unsigned lno) |
René Scharfe | 2944e4e | 2009-07-02 00:06:34 +0200 | [diff] [blame] | 1575 | { |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1576 | while (bol > gs->buf) { |
René Scharfe | 2944e4e | 2009-07-02 00:06:34 +0200 | [diff] [blame] | 1577 | char *eol = --bol; |
| 1578 | |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1579 | while (bol > gs->buf && bol[-1] != '\n') |
René Scharfe | 2944e4e | 2009-07-02 00:06:34 +0200 | [diff] [blame] | 1580 | bol--; |
| 1581 | lno--; |
| 1582 | |
| 1583 | if (lno <= opt->last_shown) |
| 1584 | break; |
| 1585 | |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1586 | if (match_funcname(opt, gs, bol, eol)) { |
Taylor Blau | 89252cd | 2018-06-22 10:49:42 -0500 | [diff] [blame] | 1587 | show_line(opt, bol, eol, gs->name, lno, 0, '='); |
René Scharfe | 2944e4e | 2009-07-02 00:06:34 +0200 | [diff] [blame] | 1588 | break; |
| 1589 | } |
| 1590 | } |
| 1591 | } |
| 1592 | |
René Scharfe | a5dc20b | 2017-11-18 19:08:08 +0100 | [diff] [blame] | 1593 | static int is_empty_line(const char *bol, const char *eol); |
| 1594 | |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1595 | static void show_pre_context(struct grep_opt *opt, struct grep_source *gs, |
René Scharfe | ba8ea74 | 2011-08-01 19:20:53 +0200 | [diff] [blame] | 1596 | char *bol, char *end, unsigned lno) |
René Scharfe | 49de321 | 2009-07-02 00:05:17 +0200 | [diff] [blame] | 1597 | { |
René Scharfe | 6653a01 | 2017-11-18 19:07:13 +0100 | [diff] [blame] | 1598 | unsigned cur = lno, from = 1, funcname_lno = 0, orig_from; |
René Scharfe | a5dc20b | 2017-11-18 19:08:08 +0100 | [diff] [blame] | 1599 | int funcname_needed = !!opt->funcname, comment_needed = 0; |
René Scharfe | ba8ea74 | 2011-08-01 19:20:53 +0200 | [diff] [blame] | 1600 | |
René Scharfe | 49de321 | 2009-07-02 00:05:17 +0200 | [diff] [blame] | 1601 | if (opt->pre_context < lno) |
| 1602 | from = lno - opt->pre_context; |
| 1603 | if (from <= opt->last_shown) |
| 1604 | from = opt->last_shown + 1; |
René Scharfe | 6653a01 | 2017-11-18 19:07:13 +0100 | [diff] [blame] | 1605 | orig_from = from; |
René Scharfe | a5dc20b | 2017-11-18 19:08:08 +0100 | [diff] [blame] | 1606 | if (opt->funcbody) { |
| 1607 | if (match_funcname(opt, gs, bol, end)) |
| 1608 | comment_needed = 1; |
| 1609 | else |
| 1610 | funcname_needed = 1; |
René Scharfe | 6653a01 | 2017-11-18 19:07:13 +0100 | [diff] [blame] | 1611 | from = opt->last_shown + 1; |
| 1612 | } |
René Scharfe | 49de321 | 2009-07-02 00:05:17 +0200 | [diff] [blame] | 1613 | |
| 1614 | /* Rewind. */ |
René Scharfe | 6653a01 | 2017-11-18 19:07:13 +0100 | [diff] [blame] | 1615 | while (bol > gs->buf && cur > from) { |
René Scharfe | a5dc20b | 2017-11-18 19:08:08 +0100 | [diff] [blame] | 1616 | char *next_bol = bol; |
René Scharfe | 2944e4e | 2009-07-02 00:06:34 +0200 | [diff] [blame] | 1617 | char *eol = --bol; |
| 1618 | |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1619 | while (bol > gs->buf && bol[-1] != '\n') |
René Scharfe | 49de321 | 2009-07-02 00:05:17 +0200 | [diff] [blame] | 1620 | bol--; |
| 1621 | cur--; |
René Scharfe | a5dc20b | 2017-11-18 19:08:08 +0100 | [diff] [blame] | 1622 | if (comment_needed && (is_empty_line(bol, eol) || |
| 1623 | match_funcname(opt, gs, bol, eol))) { |
| 1624 | comment_needed = 0; |
| 1625 | from = orig_from; |
| 1626 | if (cur < from) { |
| 1627 | cur++; |
| 1628 | bol = next_bol; |
| 1629 | break; |
| 1630 | } |
| 1631 | } |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1632 | if (funcname_needed && match_funcname(opt, gs, bol, eol)) { |
René Scharfe | 2944e4e | 2009-07-02 00:06:34 +0200 | [diff] [blame] | 1633 | funcname_lno = cur; |
| 1634 | funcname_needed = 0; |
René Scharfe | a5dc20b | 2017-11-18 19:08:08 +0100 | [diff] [blame] | 1635 | if (opt->funcbody) |
| 1636 | comment_needed = 1; |
| 1637 | else |
| 1638 | from = orig_from; |
René Scharfe | 2944e4e | 2009-07-02 00:06:34 +0200 | [diff] [blame] | 1639 | } |
René Scharfe | 49de321 | 2009-07-02 00:05:17 +0200 | [diff] [blame] | 1640 | } |
| 1641 | |
René Scharfe | 2944e4e | 2009-07-02 00:06:34 +0200 | [diff] [blame] | 1642 | /* We need to look even further back to find a function signature. */ |
| 1643 | if (opt->funcname && funcname_needed) |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1644 | show_funcname_line(opt, gs, bol, cur); |
René Scharfe | 2944e4e | 2009-07-02 00:06:34 +0200 | [diff] [blame] | 1645 | |
René Scharfe | 49de321 | 2009-07-02 00:05:17 +0200 | [diff] [blame] | 1646 | /* Back forward. */ |
| 1647 | while (cur < lno) { |
René Scharfe | 2944e4e | 2009-07-02 00:06:34 +0200 | [diff] [blame] | 1648 | char *eol = bol, sign = (cur == funcname_lno) ? '=' : '-'; |
René Scharfe | 49de321 | 2009-07-02 00:05:17 +0200 | [diff] [blame] | 1649 | |
| 1650 | while (*eol != '\n') |
| 1651 | eol++; |
Taylor Blau | 89252cd | 2018-06-22 10:49:42 -0500 | [diff] [blame] | 1652 | show_line(opt, bol, eol, gs->name, cur, 0, sign); |
René Scharfe | 49de321 | 2009-07-02 00:05:17 +0200 | [diff] [blame] | 1653 | bol = eol + 1; |
| 1654 | cur++; |
| 1655 | } |
| 1656 | } |
| 1657 | |
Junio C Hamano | a26345b | 2010-01-10 22:39:36 -0800 | [diff] [blame] | 1658 | static int should_lookahead(struct grep_opt *opt) |
| 1659 | { |
| 1660 | struct grep_pat *p; |
| 1661 | |
| 1662 | if (opt->extended) |
| 1663 | return 0; /* punt for too complex stuff */ |
| 1664 | if (opt->invert) |
| 1665 | return 0; |
| 1666 | for (p = opt->pattern_list; p; p = p->next) { |
| 1667 | if (p->token != GREP_PATTERN) |
| 1668 | return 0; /* punt for "header only" and stuff */ |
| 1669 | } |
| 1670 | return 1; |
| 1671 | } |
| 1672 | |
| 1673 | static int look_ahead(struct grep_opt *opt, |
| 1674 | unsigned long *left_p, |
| 1675 | unsigned *lno_p, |
| 1676 | char **bol_p) |
| 1677 | { |
| 1678 | unsigned lno = *lno_p; |
| 1679 | char *bol = *bol_p; |
| 1680 | struct grep_pat *p; |
| 1681 | char *sp, *last_bol; |
| 1682 | regoff_t earliest = -1; |
| 1683 | |
| 1684 | for (p = opt->pattern_list; p; p = p->next) { |
| 1685 | int hit; |
| 1686 | regmatch_t m; |
| 1687 | |
Michał Kiedrowicz | 97e7778 | 2011-05-05 00:00:19 +0200 | [diff] [blame] | 1688 | hit = patmatch(p, bol, bol + *left_p, &m, 0); |
Junio C Hamano | a26345b | 2010-01-10 22:39:36 -0800 | [diff] [blame] | 1689 | if (!hit || m.rm_so < 0 || m.rm_eo < 0) |
| 1690 | continue; |
| 1691 | if (earliest < 0 || m.rm_so < earliest) |
| 1692 | earliest = m.rm_so; |
| 1693 | } |
| 1694 | |
| 1695 | if (earliest < 0) { |
| 1696 | *bol_p = bol + *left_p; |
| 1697 | *left_p = 0; |
| 1698 | return 1; |
| 1699 | } |
| 1700 | for (sp = bol + earliest; bol < sp && sp[-1] != '\n'; sp--) |
| 1701 | ; /* find the beginning of the line */ |
| 1702 | last_bol = sp; |
| 1703 | |
| 1704 | for (sp = bol; sp < last_bol; sp++) { |
| 1705 | if (*sp == '\n') |
| 1706 | lno++; |
| 1707 | } |
| 1708 | *left_p -= last_bol - bol; |
| 1709 | *bol_p = last_bol; |
| 1710 | *lno_p = lno; |
| 1711 | return 0; |
| 1712 | } |
| 1713 | |
Nguyễn Thái Ngọc Duy | 38bbc2e | 2018-09-21 17:57:23 +0200 | [diff] [blame] | 1714 | static int fill_textconv_grep(struct repository *r, |
| 1715 | struct userdiff_driver *driver, |
Jeff King | 335ec3b | 2013-05-10 17:10:15 +0200 | [diff] [blame] | 1716 | struct grep_source *gs) |
| 1717 | { |
| 1718 | struct diff_filespec *df; |
| 1719 | char *buf; |
| 1720 | size_t size; |
| 1721 | |
| 1722 | if (!driver || !driver->textconv) |
| 1723 | return grep_source_load(gs); |
| 1724 | |
| 1725 | /* |
| 1726 | * The textconv interface is intimately tied to diff_filespecs, so we |
| 1727 | * have to pretend to be one. If we could unify the grep_source |
| 1728 | * and diff_filespec structs, this mess could just go away. |
| 1729 | */ |
| 1730 | df = alloc_filespec(gs->path); |
| 1731 | switch (gs->type) { |
Brandon Williams | 1c41c82 | 2017-05-30 10:30:44 -0700 | [diff] [blame] | 1732 | case GREP_SOURCE_OID: |
Jeff King | 335ec3b | 2013-05-10 17:10:15 +0200 | [diff] [blame] | 1733 | fill_filespec(df, gs->identifier, 1, 0100644); |
| 1734 | break; |
| 1735 | case GREP_SOURCE_FILE: |
Brandon Williams | f9704c2 | 2017-05-30 10:30:50 -0700 | [diff] [blame] | 1736 | fill_filespec(df, &null_oid, 0, 0100644); |
Jeff King | 335ec3b | 2013-05-10 17:10:15 +0200 | [diff] [blame] | 1737 | break; |
| 1738 | default: |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 1739 | BUG("attempt to textconv something without a path?"); |
Jeff King | 335ec3b | 2013-05-10 17:10:15 +0200 | [diff] [blame] | 1740 | } |
| 1741 | |
| 1742 | /* |
| 1743 | * fill_textconv is not remotely thread-safe; it may load objects |
| 1744 | * behind the scenes, and it modifies the global diff tempfile |
| 1745 | * structure. |
| 1746 | */ |
| 1747 | grep_read_lock(); |
Nguyễn Thái Ngọc Duy | 38bbc2e | 2018-09-21 17:57:23 +0200 | [diff] [blame] | 1748 | size = fill_textconv(r, driver, df, &buf); |
Jeff King | 335ec3b | 2013-05-10 17:10:15 +0200 | [diff] [blame] | 1749 | grep_read_unlock(); |
| 1750 | free_filespec(df); |
| 1751 | |
| 1752 | /* |
| 1753 | * The normal fill_textconv usage by the diff machinery would just keep |
| 1754 | * the textconv'd buf separate from the diff_filespec. But much of the |
| 1755 | * grep code passes around a grep_source and assumes that its "buf" |
| 1756 | * pointer is the beginning of the thing we are searching. So let's |
| 1757 | * install our textconv'd version into the grep_source, taking care not |
| 1758 | * to leak any existing buffer. |
| 1759 | */ |
| 1760 | grep_source_clear_data(gs); |
| 1761 | gs->buf = buf; |
| 1762 | gs->size = size; |
| 1763 | |
| 1764 | return 0; |
| 1765 | } |
| 1766 | |
René Scharfe | 4aa2c47 | 2016-05-28 17:06:19 +0200 | [diff] [blame] | 1767 | static int is_empty_line(const char *bol, const char *eol) |
| 1768 | { |
| 1769 | while (bol < eol && isspace(*bol)) |
| 1770 | bol++; |
| 1771 | return bol == eol; |
| 1772 | } |
| 1773 | |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1774 | static int grep_source_1(struct grep_opt *opt, struct grep_source *gs, int collect_hits) |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1775 | { |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1776 | char *bol; |
René Scharfe | 4aa2c47 | 2016-05-28 17:06:19 +0200 | [diff] [blame] | 1777 | char *peek_bol = NULL; |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1778 | unsigned long left; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1779 | unsigned lno = 1; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1780 | unsigned last_hit = 0; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1781 | int binary_match_only = 0; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1782 | unsigned count = 0; |
Junio C Hamano | a26345b | 2010-01-10 22:39:36 -0800 | [diff] [blame] | 1783 | int try_lookahead = 0; |
René Scharfe | ba8ea74 | 2011-08-01 19:20:53 +0200 | [diff] [blame] | 1784 | int show_function = 0; |
Jeff King | 335ec3b | 2013-05-10 17:10:15 +0200 | [diff] [blame] | 1785 | struct userdiff_driver *textconv = NULL; |
Junio C Hamano | 480c1ca | 2006-09-20 12:39:46 -0700 | [diff] [blame] | 1786 | enum grep_context ctx = GREP_CONTEXT_HEAD; |
René Scharfe | 60ecac9 | 2009-07-02 00:07:24 +0200 | [diff] [blame] | 1787 | xdemitconf_t xecfg; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1788 | |
Fredrik Kuivinen | 5b594f4 | 2010-01-25 23:51:39 +0100 | [diff] [blame] | 1789 | if (!opt->output) |
| 1790 | opt->output = std_output; |
| 1791 | |
René Scharfe | ba8ea74 | 2011-08-01 19:20:53 +0200 | [diff] [blame] | 1792 | if (opt->pre_context || opt->post_context || opt->file_break || |
| 1793 | opt->funcbody) { |
René Scharfe | 08303c3 | 2011-06-05 17:24:15 +0200 | [diff] [blame] | 1794 | /* Show hunk marks, except for the first file. */ |
| 1795 | if (opt->last_shown) |
| 1796 | opt->show_hunk_mark = 1; |
| 1797 | /* |
| 1798 | * If we're using threads then we can't easily identify |
| 1799 | * the first file. Always put hunk marks in that case |
| 1800 | * and skip the very first one later in work_done(). |
| 1801 | */ |
| 1802 | if (opt->output != std_output) |
| 1803 | opt->show_hunk_mark = 1; |
| 1804 | } |
René Scharfe | 431d6e7 | 2010-03-15 17:21:10 +0100 | [diff] [blame] | 1805 | opt->last_shown = 0; |
| 1806 | |
Jeff King | 335ec3b | 2013-05-10 17:10:15 +0200 | [diff] [blame] | 1807 | if (opt->allow_textconv) { |
Nguyễn Thái Ngọc Duy | acd00ea | 2018-09-21 17:57:33 +0200 | [diff] [blame] | 1808 | grep_source_load_driver(gs, opt->repo->index); |
Jeff King | 335ec3b | 2013-05-10 17:10:15 +0200 | [diff] [blame] | 1809 | /* |
| 1810 | * We might set up the shared textconv cache data here, which |
| 1811 | * is not thread-safe. |
| 1812 | */ |
| 1813 | grep_attr_lock(); |
| 1814 | textconv = userdiff_get_textconv(gs->driver); |
| 1815 | grep_attr_unlock(); |
| 1816 | } |
| 1817 | |
| 1818 | /* |
| 1819 | * We know the result of a textconv is text, so we only have to care |
| 1820 | * about binary handling if we are not using it. |
| 1821 | */ |
| 1822 | if (!textconv) { |
| 1823 | switch (opt->binary) { |
| 1824 | case GREP_BINARY_DEFAULT: |
Nguyễn Thái Ngọc Duy | acd00ea | 2018-09-21 17:57:33 +0200 | [diff] [blame] | 1825 | if (grep_source_is_binary(gs, opt->repo->index)) |
Jeff King | 335ec3b | 2013-05-10 17:10:15 +0200 | [diff] [blame] | 1826 | binary_match_only = 1; |
| 1827 | break; |
| 1828 | case GREP_BINARY_NOMATCH: |
Nguyễn Thái Ngọc Duy | acd00ea | 2018-09-21 17:57:33 +0200 | [diff] [blame] | 1829 | if (grep_source_is_binary(gs, opt->repo->index)) |
Jeff King | 335ec3b | 2013-05-10 17:10:15 +0200 | [diff] [blame] | 1830 | return 0; /* Assume unmatch */ |
| 1831 | break; |
| 1832 | case GREP_BINARY_TEXT: |
| 1833 | break; |
| 1834 | default: |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 1835 | BUG("unknown binary handling mode"); |
Jeff King | 335ec3b | 2013-05-10 17:10:15 +0200 | [diff] [blame] | 1836 | } |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1837 | } |
| 1838 | |
René Scharfe | 60ecac9 | 2009-07-02 00:07:24 +0200 | [diff] [blame] | 1839 | memset(&xecfg, 0, sizeof(xecfg)); |
Thomas Rast | 0579f91 | 2011-12-12 22:16:07 +0100 | [diff] [blame] | 1840 | opt->priv = &xecfg; |
| 1841 | |
Junio C Hamano | a26345b | 2010-01-10 22:39:36 -0800 | [diff] [blame] | 1842 | try_lookahead = should_lookahead(opt); |
René Scharfe | 60ecac9 | 2009-07-02 00:07:24 +0200 | [diff] [blame] | 1843 | |
Nguyễn Thái Ngọc Duy | 38bbc2e | 2018-09-21 17:57:23 +0200 | [diff] [blame] | 1844 | if (fill_textconv_grep(opt->repo, textconv, gs) < 0) |
Jeff King | 0826579 | 2012-02-02 03:21:11 -0500 | [diff] [blame] | 1845 | return 0; |
| 1846 | |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1847 | bol = gs->buf; |
| 1848 | left = gs->size; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1849 | while (left) { |
| 1850 | char *eol, ch; |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 1851 | int hit; |
Taylor Blau | 89252cd | 2018-06-22 10:49:42 -0500 | [diff] [blame] | 1852 | ssize_t cno; |
Taylor Blau | 68d686e | 2018-06-22 10:49:35 -0500 | [diff] [blame] | 1853 | ssize_t col = -1, icol = -1; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1854 | |
Junio C Hamano | a26345b | 2010-01-10 22:39:36 -0800 | [diff] [blame] | 1855 | /* |
Michał Kiedrowicz | 8997da3 | 2011-05-09 23:52:03 +0200 | [diff] [blame] | 1856 | * look_ahead() skips quickly to the line that possibly |
Junio C Hamano | a26345b | 2010-01-10 22:39:36 -0800 | [diff] [blame] | 1857 | * has the next hit; don't call it if we need to do |
| 1858 | * something more than just skipping the current line |
| 1859 | * in response to an unmatch for the current line. E.g. |
| 1860 | * inside a post-context window, we will show the current |
| 1861 | * line as a context around the previous hit when it |
| 1862 | * doesn't hit. |
| 1863 | */ |
| 1864 | if (try_lookahead |
| 1865 | && !(last_hit |
René Scharfe | ba8ea74 | 2011-08-01 19:20:53 +0200 | [diff] [blame] | 1866 | && (show_function || |
| 1867 | lno <= last_hit + opt->post_context)) |
Junio C Hamano | a26345b | 2010-01-10 22:39:36 -0800 | [diff] [blame] | 1868 | && look_ahead(opt, &left, &lno, &bol)) |
| 1869 | break; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1870 | eol = end_of_line(bol, &left); |
| 1871 | ch = *eol; |
| 1872 | *eol = 0; |
| 1873 | |
Junio C Hamano | 480c1ca | 2006-09-20 12:39:46 -0700 | [diff] [blame] | 1874 | if ((ctx == GREP_CONTEXT_HEAD) && (eol == bol)) |
| 1875 | ctx = GREP_CONTEXT_BODY; |
| 1876 | |
Taylor Blau | 68d686e | 2018-06-22 10:49:35 -0500 | [diff] [blame] | 1877 | hit = match_line(opt, bol, eol, &col, &icol, ctx, collect_hits); |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1878 | *eol = ch; |
| 1879 | |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 1880 | if (collect_hits) |
| 1881 | goto next_line; |
| 1882 | |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1883 | /* "grep -v -e foo -e bla" should list lines |
| 1884 | * that do not have either, so inversion should |
| 1885 | * be done outside. |
| 1886 | */ |
| 1887 | if (opt->invert) |
| 1888 | hit = !hit; |
| 1889 | if (opt->unmatch_name_only) { |
| 1890 | if (hit) |
| 1891 | return 0; |
| 1892 | goto next_line; |
| 1893 | } |
| 1894 | if (hit) { |
| 1895 | count++; |
| 1896 | if (opt->status_only) |
| 1897 | return 1; |
René Scharfe | 321ffcc | 2010-05-22 23:30:48 +0200 | [diff] [blame] | 1898 | if (opt->name_only) { |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1899 | show_name(opt, gs->name); |
René Scharfe | 321ffcc | 2010-05-22 23:30:48 +0200 | [diff] [blame] | 1900 | return 1; |
| 1901 | } |
René Scharfe | c30c10c | 2010-05-22 23:29:35 +0200 | [diff] [blame] | 1902 | if (opt->count) |
| 1903 | goto next_line; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1904 | if (binary_match_only) { |
Fredrik Kuivinen | 5b594f4 | 2010-01-25 23:51:39 +0100 | [diff] [blame] | 1905 | opt->output(opt, "Binary file ", 12); |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1906 | output_color(opt, gs->name, strlen(gs->name), |
Nguyễn Thái Ngọc Duy | fa151dc | 2018-05-26 15:55:22 +0200 | [diff] [blame] | 1907 | opt->colors[GREP_COLOR_FILENAME]); |
Fredrik Kuivinen | 5b594f4 | 2010-01-25 23:51:39 +0100 | [diff] [blame] | 1908 | opt->output(opt, " matches\n", 9); |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1909 | return 1; |
| 1910 | } |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1911 | /* Hit at this line. If we haven't shown the |
| 1912 | * pre-context lines, we would need to show them. |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1913 | */ |
René Scharfe | ba8ea74 | 2011-08-01 19:20:53 +0200 | [diff] [blame] | 1914 | if (opt->pre_context || opt->funcbody) |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1915 | show_pre_context(opt, gs, bol, eol, lno); |
René Scharfe | 2944e4e | 2009-07-02 00:06:34 +0200 | [diff] [blame] | 1916 | else if (opt->funcname) |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1917 | show_funcname_line(opt, gs, bol, lno); |
Taylor Blau | 89252cd | 2018-06-22 10:49:42 -0500 | [diff] [blame] | 1918 | cno = opt->invert ? icol : col; |
| 1919 | if (cno < 0) { |
| 1920 | /* |
| 1921 | * A negative cno indicates that there was no |
| 1922 | * match on the line. We are thus inverted and |
| 1923 | * being asked to show all lines that _don't_ |
| 1924 | * match a given expression. Therefore, set cno |
| 1925 | * to 0 to suggest the whole line matches. |
| 1926 | */ |
| 1927 | cno = 0; |
| 1928 | } |
| 1929 | show_line(opt, bol, eol, gs->name, lno, cno + 1, ':'); |
René Scharfe | 5dd06d3 | 2009-07-02 00:02:38 +0200 | [diff] [blame] | 1930 | last_hit = lno; |
René Scharfe | ba8ea74 | 2011-08-01 19:20:53 +0200 | [diff] [blame] | 1931 | if (opt->funcbody) |
| 1932 | show_function = 1; |
| 1933 | goto next_line; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1934 | } |
René Scharfe | 4aa2c47 | 2016-05-28 17:06:19 +0200 | [diff] [blame] | 1935 | if (show_function && (!peek_bol || peek_bol < bol)) { |
| 1936 | unsigned long peek_left = left; |
| 1937 | char *peek_eol = eol; |
| 1938 | |
| 1939 | /* |
| 1940 | * Trailing empty lines are not interesting. |
| 1941 | * Peek past them to see if they belong to the |
| 1942 | * body of the current function. |
| 1943 | */ |
| 1944 | peek_bol = bol; |
| 1945 | while (is_empty_line(peek_bol, peek_eol)) { |
| 1946 | peek_bol = peek_eol + 1; |
| 1947 | peek_eol = end_of_line(peek_bol, &peek_left); |
| 1948 | } |
| 1949 | |
| 1950 | if (match_funcname(opt, gs, peek_bol, peek_eol)) |
| 1951 | show_function = 0; |
| 1952 | } |
René Scharfe | ba8ea74 | 2011-08-01 19:20:53 +0200 | [diff] [blame] | 1953 | if (show_function || |
| 1954 | (last_hit && lno <= last_hit + opt->post_context)) { |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1955 | /* If the last hit is within the post context, |
| 1956 | * we need to show this line. |
| 1957 | */ |
Taylor Blau | 89252cd | 2018-06-22 10:49:42 -0500 | [diff] [blame] | 1958 | show_line(opt, bol, eol, gs->name, lno, col + 1, '-'); |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1959 | } |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1960 | |
| 1961 | next_line: |
| 1962 | bol = eol + 1; |
| 1963 | if (!left) |
| 1964 | break; |
| 1965 | left--; |
| 1966 | lno++; |
| 1967 | } |
| 1968 | |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 1969 | if (collect_hits) |
| 1970 | return 0; |
Junio C Hamano | b48fb5b | 2006-09-27 16:27:10 -0700 | [diff] [blame] | 1971 | |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1972 | if (opt->status_only) |
Anthony Sottile | e1f68c6 | 2017-08-17 18:38:51 -0700 | [diff] [blame] | 1973 | return opt->unmatch_name_only; |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1974 | if (opt->unmatch_name_only) { |
| 1975 | /* We did not see any hit, so we want to show this */ |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 1976 | show_name(opt, gs->name); |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1977 | return 1; |
| 1978 | } |
| 1979 | |
René Scharfe | 60ecac9 | 2009-07-02 00:07:24 +0200 | [diff] [blame] | 1980 | xdiff_clear_find_func(&xecfg); |
| 1981 | opt->priv = NULL; |
| 1982 | |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1983 | /* NEEDSWORK: |
| 1984 | * The real "grep -c foo *.c" gives many "bar.c:0" lines, |
| 1985 | * which feels mostly useless but sometimes useful. Maybe |
| 1986 | * make it another option? For now suppress them. |
| 1987 | */ |
Fredrik Kuivinen | 5b594f4 | 2010-01-25 23:51:39 +0100 | [diff] [blame] | 1988 | if (opt->count && count) { |
| 1989 | char buf[32]; |
René Scharfe | f76d947 | 2014-03-11 22:15:49 +0100 | [diff] [blame] | 1990 | if (opt->pathname) { |
| 1991 | output_color(opt, gs->name, strlen(gs->name), |
Nguyễn Thái Ngọc Duy | fa151dc | 2018-05-26 15:55:22 +0200 | [diff] [blame] | 1992 | opt->colors[GREP_COLOR_FILENAME]); |
René Scharfe | f76d947 | 2014-03-11 22:15:49 +0100 | [diff] [blame] | 1993 | output_sep(opt, ':'); |
| 1994 | } |
Jeff King | 1a168e5 | 2017-03-28 15:46:56 -0400 | [diff] [blame] | 1995 | xsnprintf(buf, sizeof(buf), "%u\n", count); |
Fredrik Kuivinen | 5b594f4 | 2010-01-25 23:51:39 +0100 | [diff] [blame] | 1996 | opt->output(opt, buf, strlen(buf)); |
René Scharfe | c30c10c | 2010-05-22 23:29:35 +0200 | [diff] [blame] | 1997 | return 1; |
Fredrik Kuivinen | 5b594f4 | 2010-01-25 23:51:39 +0100 | [diff] [blame] | 1998 | } |
Junio C Hamano | 83b5d2f | 2006-09-17 16:02:52 -0700 | [diff] [blame] | 1999 | return !!last_hit; |
| 2000 | } |
| 2001 | |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 2002 | static void clr_hit_marker(struct grep_expr *x) |
| 2003 | { |
| 2004 | /* All-hit markers are meaningful only at the very top level |
| 2005 | * OR node. |
| 2006 | */ |
| 2007 | while (1) { |
| 2008 | x->hit = 0; |
| 2009 | if (x->node != GREP_NODE_OR) |
| 2010 | return; |
| 2011 | x->u.binary.left->hit = 0; |
| 2012 | x = x->u.binary.right; |
| 2013 | } |
| 2014 | } |
| 2015 | |
| 2016 | static int chk_hit_marker(struct grep_expr *x) |
| 2017 | { |
| 2018 | /* Top level nodes have hit markers. See if they all are hits */ |
| 2019 | while (1) { |
| 2020 | if (x->node != GREP_NODE_OR) |
| 2021 | return x->hit; |
| 2022 | if (!x->u.binary.left->hit) |
| 2023 | return 0; |
| 2024 | x = x->u.binary.right; |
| 2025 | } |
| 2026 | } |
| 2027 | |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2028 | int grep_source(struct grep_opt *opt, struct grep_source *gs) |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 2029 | { |
| 2030 | /* |
| 2031 | * we do not have to do the two-pass grep when we do not check |
| 2032 | * buffer-wide "all-match". |
| 2033 | */ |
| 2034 | if (!opt->all_match) |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2035 | return grep_source_1(opt, gs, 0); |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 2036 | |
| 2037 | /* Otherwise the toplevel "or" terms hit a bit differently. |
| 2038 | * We first clear hit markers from them. |
| 2039 | */ |
| 2040 | clr_hit_marker(opt->pattern_expression); |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2041 | grep_source_1(opt, gs, 1); |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 2042 | |
| 2043 | if (!chk_hit_marker(opt->pattern_expression)) |
| 2044 | return 0; |
| 2045 | |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2046 | return grep_source_1(opt, gs, 0); |
| 2047 | } |
| 2048 | |
Jeff King | c876d6d | 2012-02-02 03:20:10 -0500 | [diff] [blame] | 2049 | int grep_buffer(struct grep_opt *opt, char *buf, unsigned long size) |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2050 | { |
| 2051 | struct grep_source gs; |
| 2052 | int r; |
| 2053 | |
Nguyễn Thái Ngọc Duy | 55c6168 | 2012-10-12 17:49:38 +0700 | [diff] [blame] | 2054 | grep_source_init(&gs, GREP_SOURCE_BUF, NULL, NULL, NULL); |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2055 | gs.buf = buf; |
| 2056 | gs.size = size; |
| 2057 | |
| 2058 | r = grep_source(opt, &gs); |
| 2059 | |
| 2060 | grep_source_clear(&gs); |
| 2061 | return r; |
| 2062 | } |
| 2063 | |
| 2064 | void grep_source_init(struct grep_source *gs, enum grep_source_type type, |
Nguyễn Thái Ngọc Duy | 55c6168 | 2012-10-12 17:49:38 +0700 | [diff] [blame] | 2065 | const char *name, const char *path, |
| 2066 | const void *identifier) |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2067 | { |
| 2068 | gs->type = type; |
Jeff King | 8c53f07 | 2015-01-12 20:59:09 -0500 | [diff] [blame] | 2069 | gs->name = xstrdup_or_null(name); |
| 2070 | gs->path = xstrdup_or_null(path); |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2071 | gs->buf = NULL; |
| 2072 | gs->size = 0; |
Jeff King | 94ad9d9 | 2012-02-02 03:20:43 -0500 | [diff] [blame] | 2073 | gs->driver = NULL; |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2074 | |
| 2075 | switch (type) { |
| 2076 | case GREP_SOURCE_FILE: |
| 2077 | gs->identifier = xstrdup(identifier); |
| 2078 | break; |
Brandon Williams | 1c41c82 | 2017-05-30 10:30:44 -0700 | [diff] [blame] | 2079 | case GREP_SOURCE_OID: |
| 2080 | gs->identifier = oiddup(identifier); |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2081 | break; |
| 2082 | case GREP_SOURCE_BUF: |
| 2083 | gs->identifier = NULL; |
Brandon Williams | 4538eef | 2016-12-16 11:03:19 -0800 | [diff] [blame] | 2084 | break; |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2085 | } |
| 2086 | } |
| 2087 | |
| 2088 | void grep_source_clear(struct grep_source *gs) |
| 2089 | { |
Ævar Arnfjörð Bjarmason | 88ce3ef | 2017-06-15 23:15:49 +0000 | [diff] [blame] | 2090 | FREE_AND_NULL(gs->name); |
| 2091 | FREE_AND_NULL(gs->path); |
| 2092 | FREE_AND_NULL(gs->identifier); |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2093 | grep_source_clear_data(gs); |
| 2094 | } |
| 2095 | |
| 2096 | void grep_source_clear_data(struct grep_source *gs) |
| 2097 | { |
| 2098 | switch (gs->type) { |
| 2099 | case GREP_SOURCE_FILE: |
Brandon Williams | 1c41c82 | 2017-05-30 10:30:44 -0700 | [diff] [blame] | 2100 | case GREP_SOURCE_OID: |
Ævar Arnfjörð Bjarmason | 6a83d90 | 2017-06-15 23:15:46 +0000 | [diff] [blame] | 2101 | FREE_AND_NULL(gs->buf); |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2102 | gs->size = 0; |
| 2103 | break; |
| 2104 | case GREP_SOURCE_BUF: |
| 2105 | /* leave user-provided buf intact */ |
| 2106 | break; |
| 2107 | } |
| 2108 | } |
| 2109 | |
Brandon Williams | 1c41c82 | 2017-05-30 10:30:44 -0700 | [diff] [blame] | 2110 | static int grep_source_load_oid(struct grep_source *gs) |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2111 | { |
| 2112 | enum object_type type; |
| 2113 | |
| 2114 | grep_read_lock(); |
brian m. carlson | b4f5aca | 2018-03-12 02:27:53 +0000 | [diff] [blame] | 2115 | gs->buf = read_object_file(gs->identifier, &type, &gs->size); |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2116 | grep_read_unlock(); |
| 2117 | |
| 2118 | if (!gs->buf) |
| 2119 | return error(_("'%s': unable to read %s"), |
| 2120 | gs->name, |
Brandon Williams | 1c41c82 | 2017-05-30 10:30:44 -0700 | [diff] [blame] | 2121 | oid_to_hex(gs->identifier)); |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2122 | return 0; |
| 2123 | } |
| 2124 | |
| 2125 | static int grep_source_load_file(struct grep_source *gs) |
| 2126 | { |
| 2127 | const char *filename = gs->identifier; |
| 2128 | struct stat st; |
| 2129 | char *data; |
| 2130 | size_t size; |
| 2131 | int i; |
| 2132 | |
| 2133 | if (lstat(filename, &st) < 0) { |
| 2134 | err_ret: |
| 2135 | if (errno != ENOENT) |
Nguyễn Thái Ngọc Duy | 7645d8f | 2016-05-08 16:47:47 +0700 | [diff] [blame] | 2136 | error_errno(_("failed to stat '%s'"), filename); |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2137 | return -1; |
| 2138 | } |
| 2139 | if (!S_ISREG(st.st_mode)) |
| 2140 | return -1; |
| 2141 | size = xsize_t(st.st_size); |
| 2142 | i = open(filename, O_RDONLY); |
| 2143 | if (i < 0) |
| 2144 | goto err_ret; |
Jeff King | 3733e69 | 2016-02-22 17:44:28 -0500 | [diff] [blame] | 2145 | data = xmallocz(size); |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2146 | if (st.st_size != read_in_full(i, data, size)) { |
Nguyễn Thái Ngọc Duy | 7645d8f | 2016-05-08 16:47:47 +0700 | [diff] [blame] | 2147 | error_errno(_("'%s': short read"), filename); |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2148 | close(i); |
| 2149 | free(data); |
| 2150 | return -1; |
| 2151 | } |
| 2152 | close(i); |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2153 | |
| 2154 | gs->buf = data; |
| 2155 | gs->size = size; |
| 2156 | return 0; |
| 2157 | } |
| 2158 | |
Junio C Hamano | 3083301 | 2012-09-20 14:20:09 -0700 | [diff] [blame] | 2159 | static int grep_source_load(struct grep_source *gs) |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2160 | { |
| 2161 | if (gs->buf) |
| 2162 | return 0; |
| 2163 | |
| 2164 | switch (gs->type) { |
| 2165 | case GREP_SOURCE_FILE: |
| 2166 | return grep_source_load_file(gs); |
Brandon Williams | 1c41c82 | 2017-05-30 10:30:44 -0700 | [diff] [blame] | 2167 | case GREP_SOURCE_OID: |
| 2168 | return grep_source_load_oid(gs); |
Jeff King | e132702 | 2012-02-02 03:19:28 -0500 | [diff] [blame] | 2169 | case GREP_SOURCE_BUF: |
| 2170 | return gs->buf ? 0 : -1; |
| 2171 | } |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 2172 | BUG("invalid grep_source type to load"); |
Junio C Hamano | 0ab7bef | 2006-09-27 17:50:52 -0700 | [diff] [blame] | 2173 | } |
Jeff King | 94ad9d9 | 2012-02-02 03:20:43 -0500 | [diff] [blame] | 2174 | |
Nguyễn Thái Ngọc Duy | acd00ea | 2018-09-21 17:57:33 +0200 | [diff] [blame] | 2175 | void grep_source_load_driver(struct grep_source *gs, |
| 2176 | struct index_state *istate) |
Jeff King | 94ad9d9 | 2012-02-02 03:20:43 -0500 | [diff] [blame] | 2177 | { |
| 2178 | if (gs->driver) |
| 2179 | return; |
| 2180 | |
| 2181 | grep_attr_lock(); |
Nguyễn Thái Ngọc Duy | 55c6168 | 2012-10-12 17:49:38 +0700 | [diff] [blame] | 2182 | if (gs->path) |
Nguyễn Thái Ngọc Duy | acd00ea | 2018-09-21 17:57:33 +0200 | [diff] [blame] | 2183 | gs->driver = userdiff_find_by_path(istate, gs->path); |
Jeff King | 94ad9d9 | 2012-02-02 03:20:43 -0500 | [diff] [blame] | 2184 | if (!gs->driver) |
| 2185 | gs->driver = userdiff_find_by_name("default"); |
| 2186 | grep_attr_unlock(); |
| 2187 | } |
Jeff King | 41b59bf | 2012-02-02 03:21:02 -0500 | [diff] [blame] | 2188 | |
Nguyễn Thái Ngọc Duy | acd00ea | 2018-09-21 17:57:33 +0200 | [diff] [blame] | 2189 | static int grep_source_is_binary(struct grep_source *gs, |
| 2190 | struct index_state *istate) |
Jeff King | 41b59bf | 2012-02-02 03:21:02 -0500 | [diff] [blame] | 2191 | { |
Nguyễn Thái Ngọc Duy | acd00ea | 2018-09-21 17:57:33 +0200 | [diff] [blame] | 2192 | grep_source_load_driver(gs, istate); |
Jeff King | 41b59bf | 2012-02-02 03:21:02 -0500 | [diff] [blame] | 2193 | if (gs->driver->binary != -1) |
| 2194 | return gs->driver->binary; |
| 2195 | |
| 2196 | if (!grep_source_load(gs)) |
| 2197 | return buffer_is_binary(gs->buf, gs->size); |
| 2198 | |
| 2199 | return 0; |
| 2200 | } |