git.oblomov.eu Git - git/blob - grep.c

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