grep.c

   1 #include "cache.h"
   2 #include "grep.h"
   3 #include "userdiff.h"
   4 #include "xdiff-interface.h"
   5
   6 void append_header_grep_pattern(struct grep_opt *opt, enum grep_header_field field, const char *pat)
   7 {
   8         struct grep_pat *p = xcalloc(1, sizeof(*p));
   9         p->pattern = pat;
  10         p->origin = "header";
  11         p->no = 0;
  12         p->token = GREP_PATTERN_HEAD;
  13         p->field = field;
  14         *opt->pattern_tail = p;
  15         opt->pattern_tail = &p->next;
  16         p->next = NULL;
  17 }
  18
  19 void append_grep_pattern(struct grep_opt *opt, const char *pat,
  20                          const char *origin, int no, enum grep_pat_token t)
  21 {
  22         struct grep_pat *p = xcalloc(1, sizeof(*p));
  23         p->pattern = pat;
  24         p->origin = origin;
  25         p->no = no;
  26         p->token = t;
  27         *opt->pattern_tail = p;
  28         opt->pattern_tail = &p->next;
  29         p->next = NULL;
  30 }
  31
  32 static int is_fixed(const char *s)
  33 {
  34         while (*s && !is_regex_special(*s))
  35                 s++;
  36         return !*s;
  37 }
  38
  39 static void compile_regexp(struct grep_pat *p, struct grep_opt *opt)
  40 {
  41         int err;
  42
  43         p->word_regexp = opt->word_regexp;
  44
  45         if (opt->fixed || is_fixed(p->pattern))
  46                 p->fixed = 1;
  47         if (opt->regflags & REG_ICASE)
  48                 p->fixed = 0;
  49         if (p->fixed)
  50                 return;
  51
  52         err = regcomp(&p->regexp, p->pattern, opt->regflags);
  53         if (err) {
  54                 char errbuf[1024];
  55                 char where[1024];
  56                 if (p->no)
  57                         sprintf(where, "In '%s' at %d, ",
  58                                 p->origin, p->no);
  59                 else if (p->origin)
  60                         sprintf(where, "%s, ", p->origin);
  61                 else
  62                         where[0] = 0;
  63                 regerror(err, &p->regexp, errbuf, 1024);
  64                 regfree(&p->regexp);
  65                 die("%s'%s': %s", where, p->pattern, errbuf);
  66         }
  67 }
  68
  69 static struct grep_expr *compile_pattern_or(struct grep_pat **);
  70 static struct grep_expr *compile_pattern_atom(struct grep_pat **list)
  71 {
  72         struct grep_pat *p;
  73         struct grep_expr *x;
  74
  75         p = *list;
  76         if (!p)
  77                 return NULL;
  78         switch (p->token) {
  79         case GREP_PATTERN: /* atom */
  80         case GREP_PATTERN_HEAD:
  81         case GREP_PATTERN_BODY:
  82                 x = xcalloc(1, sizeof (struct grep_expr));
  83                 x->node = GREP_NODE_ATOM;
  84                 x->u.atom = p;
  85                 *list = p->next;
  86                 return x;
  87         case GREP_OPEN_PAREN:
  88                 *list = p->next;
  89                 x = compile_pattern_or(list);
  90                 if (!*list || (*list)->token != GREP_CLOSE_PAREN)
  91                         die("unmatched parenthesis");
  92                 *list = (*list)->next;
  93                 return x;
  94         default:
  95                 return NULL;
  96         }
  97 }
  98
  99 static struct grep_expr *compile_pattern_not(struct grep_pat **list)
 100 {
 101         struct grep_pat *p;
 102         struct grep_expr *x;
 103
 104         p = *list;
 105         if (!p)
 106                 return NULL;
 107         switch (p->token) {
 108         case GREP_NOT:
 109                 if (!p->next)
 110                         die("--not not followed by pattern expression");
 111                 *list = p->next;
 112                 x = xcalloc(1, sizeof (struct grep_expr));
 113                 x->node = GREP_NODE_NOT;
 114                 x->u.unary = compile_pattern_not(list);
 115                 if (!x->u.unary)
 116                         die("--not followed by non pattern expression");
 117                 return x;
 118         default:
 119                 return compile_pattern_atom(list);
 120         }
 121 }
 122
 123 static struct grep_expr *compile_pattern_and(struct grep_pat **list)
 124 {
 125         struct grep_pat *p;
 126         struct grep_expr *x, *y, *z;
 127
 128         x = compile_pattern_not(list);
 129         p = *list;
 130         if (p && p->token == GREP_AND) {
 131                 if (!p->next)
 132                         die("--and not followed by pattern expression");
 133                 *list = p->next;
 134                 y = compile_pattern_and(list);
 135                 if (!y)
 136                         die("--and not followed by pattern expression");
 137                 z = xcalloc(1, sizeof (struct grep_expr));
 138                 z->node = GREP_NODE_AND;
 139                 z->u.binary.left = x;
 140                 z->u.binary.right = y;
 141                 return z;
 142         }
 143         return x;
 144 }
 145
 146 static struct grep_expr *compile_pattern_or(struct grep_pat **list)
 147 {
 148         struct grep_pat *p;
 149         struct grep_expr *x, *y, *z;
 150
 151         x = compile_pattern_and(list);
 152         p = *list;
 153         if (x && p && p->token != GREP_CLOSE_PAREN) {
 154                 y = compile_pattern_or(list);
 155                 if (!y)
 156                         die("not a pattern expression %s", p->pattern);
 157                 z = xcalloc(1, sizeof (struct grep_expr));
 158                 z->node = GREP_NODE_OR;
 159                 z->u.binary.left = x;
 160                 z->u.binary.right = y;
 161                 return z;
 162         }
 163         return x;
 164 }
 165
 166 static struct grep_expr *compile_pattern_expr(struct grep_pat **list)
 167 {
 168         return compile_pattern_or(list);
 169 }
 170
 171 void compile_grep_patterns(struct grep_opt *opt)
 172 {
 173         struct grep_pat *p;
 174
 175         if (opt->all_match)
 176                 opt->extended = 1;
 177
 178         for (p = opt->pattern_list; p; p = p->next) {
 179                 switch (p->token) {
 180                 case GREP_PATTERN: /* atom */
 181                 case GREP_PATTERN_HEAD:
 182                 case GREP_PATTERN_BODY:
 183                         compile_regexp(p, opt);
 184                         break;
 185                 default:
 186                         opt->extended = 1;
 187                         break;
 188                 }
 189         }
 190
 191         if (!opt->extended)
 192                 return;
 193
 194         /* Then bundle them up in an expression.
 195          * A classic recursive descent parser would do.
 196          */
 197         p = opt->pattern_list;
 198         if (p)
 199                 opt->pattern_expression = compile_pattern_expr(&p);
 200         if (p)
 201                 die("incomplete pattern expression: %s", p->pattern);
 202 }
 203
 204 static void free_pattern_expr(struct grep_expr *x)
 205 {
 206         switch (x->node) {
 207         case GREP_NODE_ATOM:
 208                 break;
 209         case GREP_NODE_NOT:
 210                 free_pattern_expr(x->u.unary);
 211                 break;
 212         case GREP_NODE_AND:
 213         case GREP_NODE_OR:
 214                 free_pattern_expr(x->u.binary.left);
 215                 free_pattern_expr(x->u.binary.right);
 216                 break;
 217         }
 218         free(x);
 219 }
 220
 221 void free_grep_patterns(struct grep_opt *opt)
 222 {
 223         struct grep_pat *p, *n;
 224
 225         for (p = opt->pattern_list; p; p = n) {
 226                 n = p->next;
 227                 switch (p->token) {
 228                 case GREP_PATTERN: /* atom */
 229                 case GREP_PATTERN_HEAD:
 230                 case GREP_PATTERN_BODY:
 231                         regfree(&p->regexp);
 232                         break;
 233                 default:
 234                         break;
 235                 }
 236                 free(p);
 237         }
 238
 239         if (!opt->extended)
 240                 return;
 241         free_pattern_expr(opt->pattern_expression);
 242 }
 243
 244 static char *end_of_line(char *cp, unsigned long *left)
 245 {
 246         unsigned long l = *left;
 247         while (l && *cp != '\n') {
 248                 l--;
 249                 cp++;
 250         }
 251         *left = l;
 252         return cp;
 253 }
 254
 255 static int word_char(char ch)
 256 {
 257         return isalnum(ch) || ch == '_';
 258 }
 259
 260 static void show_name(struct grep_opt *opt, const char *name)
 261 {
 262         printf("%s%c", name, opt->null_following_name ? '\0' : '\n');
 263 }
 264
 265 static int fixmatch(const char *pattern, char *line, regmatch_t *match)
 266 {
 267         char *hit = strstr(line, pattern);
 268         if (!hit) {
 269                 match->rm_so = match->rm_eo = -1;
 270                 return REG_NOMATCH;
 271         }
 272         else {
 273                 match->rm_so = hit - line;
 274                 match->rm_eo = match->rm_so + strlen(pattern);
 275                 return 0;
 276         }
 277 }
 278
 279 static int strip_timestamp(char *bol, char **eol_p)
 280 {
 281         char *eol = *eol_p;
 282         int ch;
 283
 284         while (bol < --eol) {
 285                 if (*eol != '>')
 286                         continue;
 287                 *eol_p = ++eol;
 288                 ch = *eol;
 289                 *eol = '\0';
 290                 return ch;
 291         }
 292         return 0;
 293 }
 294
 295 static struct {
 296         const char *field;
 297         size_t len;
 298 } header_field[] = {
 299         { "author ", 7 },
 300         { "committer ", 10 },
 301 };
 302
 303 static int match_one_pattern(struct grep_pat *p, char *bol, char *eol,
 304                              enum grep_context ctx,
 305                              regmatch_t *pmatch, int eflags)
 306 {
 307         int hit = 0;
 308         int saved_ch = 0;
 309         const char *start = bol;
 310
 311         if ((p->token != GREP_PATTERN) &&
 312             ((p->token == GREP_PATTERN_HEAD) != (ctx == GREP_CONTEXT_HEAD)))
 313                 return 0;
 314
 315         if (p->token == GREP_PATTERN_HEAD) {
 316                 const char *field;
 317                 size_t len;
 318                 assert(p->field < ARRAY_SIZE(header_field));
 319                 field = header_field[p->field].field;
 320                 len = header_field[p->field].len;
 321                 if (strncmp(bol, field, len))
 322                         return 0;
 323                 bol += len;
 324                 saved_ch = strip_timestamp(bol, &eol);
 325         }
 326
 327  again:
 328         if (p->fixed)
 329                 hit = !fixmatch(p->pattern, bol, pmatch);
 330         else
 331                 hit = !regexec(&p->regexp, bol, 1, pmatch, eflags);
 332
 333         if (hit && p->word_regexp) {
 334                 if ((pmatch[0].rm_so < 0) ||
 335                     (eol - bol) < pmatch[0].rm_so ||
 336                     (pmatch[0].rm_eo < 0) ||
 337                     (eol - bol) < pmatch[0].rm_eo)
 338                         die("regexp returned nonsense");
 339
 340                 /* Match beginning must be either beginning of the
 341                  * line, or at word boundary (i.e. the last char must
 342                  * not be a word char).  Similarly, match end must be
 343                  * either end of the line, or at word boundary
 344                  * (i.e. the next char must not be a word char).
 345                  */
 346                 if ( ((pmatch[0].rm_so == 0) ||
 347                       !word_char(bol[pmatch[0].rm_so-1])) &&
 348                      ((pmatch[0].rm_eo == (eol-bol)) ||
 349                       !word_char(bol[pmatch[0].rm_eo])) )
 350                         ;
 351                 else
 352                         hit = 0;
 353
 354                 /* Words consist of at least one character. */
 355                 if (pmatch->rm_so == pmatch->rm_eo)
 356                         hit = 0;
 357
 358                 if (!hit && pmatch[0].rm_so + bol + 1 < eol) {
 359                         /* There could be more than one match on the
 360                          * line, and the first match might not be
 361                          * strict word match.  But later ones could be!
 362                          * Forward to the next possible start, i.e. the
 363                          * next position following a non-word char.
 364                          */
 365                         bol = pmatch[0].rm_so + bol + 1;
 366                         while (word_char(bol[-1]) && bol < eol)
 367                                 bol++;
 368                         eflags |= REG_NOTBOL;
 369                         if (bol < eol)
 370                                 goto again;
 371                 }
 372         }
 373         if (p->token == GREP_PATTERN_HEAD && saved_ch)
 374                 *eol = saved_ch;
 375         if (hit) {
 376                 pmatch[0].rm_so += bol - start;
 377                 pmatch[0].rm_eo += bol - start;
 378         }
 379         return hit;
 380 }
 381
 382 static int match_expr_eval(struct grep_expr *x, char *bol, char *eol,
 383                            enum grep_context ctx, int collect_hits)
 384 {
 385         int h = 0;
 386         regmatch_t match;
 387
 388         if (!x)
 389                 die("Not a valid grep expression");
 390         switch (x->node) {
 391         case GREP_NODE_ATOM:
 392                 h = match_one_pattern(x->u.atom, bol, eol, ctx, &match, 0);
 393                 break;
 394         case GREP_NODE_NOT:
 395                 h = !match_expr_eval(x->u.unary, bol, eol, ctx, 0);
 396                 break;
 397         case GREP_NODE_AND:
 398                 if (!match_expr_eval(x->u.binary.left, bol, eol, ctx, 0))
 399                         return 0;
 400                 h = match_expr_eval(x->u.binary.right, bol, eol, ctx, 0);
 401                 break;
 402         case GREP_NODE_OR:
 403                 if (!collect_hits)
 404                         return (match_expr_eval(x->u.binary.left,
 405                                                 bol, eol, ctx, 0) ||
 406                                 match_expr_eval(x->u.binary.right,
 407                                                 bol, eol, ctx, 0));
 408                 h = match_expr_eval(x->u.binary.left, bol, eol, ctx, 0);
 409                 x->u.binary.left->hit |= h;
 410                 h |= match_expr_eval(x->u.binary.right, bol, eol, ctx, 1);
 411                 break;
 412         default:
 413                 die("Unexpected node type (internal error) %d", x->node);
 414         }
 415         if (collect_hits)
 416                 x->hit |= h;
 417         return h;
 418 }
 419
 420 static int match_expr(struct grep_opt *opt, char *bol, char *eol,
 421                       enum grep_context ctx, int collect_hits)
 422 {
 423         struct grep_expr *x = opt->pattern_expression;
 424         return match_expr_eval(x, bol, eol, ctx, collect_hits);
 425 }
 426
 427 static int match_line(struct grep_opt *opt, char *bol, char *eol,
 428                       enum grep_context ctx, int collect_hits)
 429 {
 430         struct grep_pat *p;
 431         regmatch_t match;
 432
 433         if (opt->extended)
 434                 return match_expr(opt, bol, eol, ctx, collect_hits);
 435
 436         /* we do not call with collect_hits without being extended */
 437         for (p = opt->pattern_list; p; p = p->next) {
 438                 if (match_one_pattern(p, bol, eol, ctx, &match, 0))
 439                         return 1;
 440         }
 441         return 0;
 442 }
 443
 444 static int match_next_pattern(struct grep_pat *p, char *bol, char *eol,
 445                               enum grep_context ctx,
 446                               regmatch_t *pmatch, int eflags)
 447 {
 448         regmatch_t match;
 449
 450         if (!match_one_pattern(p, bol, eol, ctx, &match, eflags))
 451                 return 0;
 452         if (match.rm_so < 0 || match.rm_eo < 0)
 453                 return 0;
 454         if (pmatch->rm_so >= 0 && pmatch->rm_eo >= 0) {
 455                 if (match.rm_so > pmatch->rm_so)
 456                         return 1;
 457                 if (match.rm_so == pmatch->rm_so && match.rm_eo < pmatch->rm_eo)
 458                         return 1;
 459         }
 460         pmatch->rm_so = match.rm_so;
 461         pmatch->rm_eo = match.rm_eo;
 462         return 1;
 463 }
 464
 465 static int next_match(struct grep_opt *opt, char *bol, char *eol,
 466                       enum grep_context ctx, regmatch_t *pmatch, int eflags)
 467 {
 468         struct grep_pat *p;
 469         int hit = 0;
 470
 471         pmatch->rm_so = pmatch->rm_eo = -1;
 472         if (bol < eol) {
 473                 for (p = opt->pattern_list; p; p = p->next) {
 474                         switch (p->token) {
 475                         case GREP_PATTERN: /* atom */
 476                         case GREP_PATTERN_HEAD:
 477                         case GREP_PATTERN_BODY:
 478                                 hit |= match_next_pattern(p, bol, eol, ctx,
 479                                                           pmatch, eflags);
 480                                 break;
 481                         default:
 482                                 break;
 483                         }
 484                 }
 485         }
 486         return hit;
 487 }
 488
 489 static void show_line(struct grep_opt *opt, char *bol, char *eol,
 490                       const char *name, unsigned lno, char sign)
 491 {
 492         int rest = eol - bol;
 493
 494         if (opt->pre_context || opt->post_context) {
 495                 if (opt->last_shown == 0) {
 496                         if (opt->show_hunk_mark)
 497                                 fputs("--\n", stdout);
 498                         else
 499                                 opt->show_hunk_mark = 1;
 500                 } else if (lno > opt->last_shown + 1)
 501                         fputs("--\n", stdout);
 502         }
 503         opt->last_shown = lno;
 504
 505         if (opt->null_following_name)
 506                 sign = '\0';
 507         if (opt->pathname)
 508                 printf("%s%c", name, sign);
 509         if (opt->linenum)
 510                 printf("%d%c", lno, sign);
 511         if (opt->color) {
 512                 regmatch_t match;
 513                 enum grep_context ctx = GREP_CONTEXT_BODY;
 514                 int ch = *eol;
 515                 int eflags = 0;
 516
 517                 *eol = '\0';
 518                 while (next_match(opt, bol, eol, ctx, &match, eflags)) {
 519                         if (match.rm_so == match.rm_eo)
 520                                 break;
 521                         printf("%.*s%s%.*s%s",
 522                                (int)match.rm_so, bol,
 523                                opt->color_match,
 524                                (int)(match.rm_eo - match.rm_so), bol + match.rm_so,
 525                                GIT_COLOR_RESET);
 526                         bol += match.rm_eo;
 527                         rest -= match.rm_eo;
 528                         eflags = REG_NOTBOL;
 529                 }
 530                 *eol = ch;
 531         }
 532         printf("%.*s\n", rest, bol);
 533 }
 534
 535 static int match_funcname(struct grep_opt *opt, char *bol, char *eol)
 536 {
 537         xdemitconf_t *xecfg = opt->priv;
 538         if (xecfg && xecfg->find_func) {
 539                 char buf[1];
 540                 return xecfg->find_func(bol, eol - bol, buf, 1,
 541                                         xecfg->find_func_priv) >= 0;
 542         }
 543
 544         if (bol == eol)
 545                 return 0;
 546         if (isalpha(*bol) || *bol == '_' || *bol == '$')
 547                 return 1;
 548         return 0;
 549 }
 550
 551 static void show_funcname_line(struct grep_opt *opt, const char *name,
 552                                char *buf, char *bol, unsigned lno)
 553 {
 554         while (bol > buf) {
 555                 char *eol = --bol;
 556
 557                 while (bol > buf && bol[-1] != '\n')
 558                         bol--;
 559                 lno--;
 560
 561                 if (lno <= opt->last_shown)
 562                         break;
 563
 564                 if (match_funcname(opt, bol, eol)) {
 565                         show_line(opt, bol, eol, name, lno, '=');
 566                         break;
 567                 }
 568         }
 569 }
 570
 571 static void show_pre_context(struct grep_opt *opt, const char *name, char *buf,
 572                              char *bol, unsigned lno)
 573 {
 574         unsigned cur = lno, from = 1, funcname_lno = 0;
 575         int funcname_needed = opt->funcname;
 576
 577         if (opt->pre_context < lno)
 578                 from = lno - opt->pre_context;
 579         if (from <= opt->last_shown)
 580                 from = opt->last_shown + 1;
 581
 582         /* Rewind. */
 583         while (bol > buf && cur > from) {
 584                 char *eol = --bol;
 585
 586                 while (bol > buf && bol[-1] != '\n')
 587                         bol--;
 588                 cur--;
 589                 if (funcname_needed && match_funcname(opt, bol, eol)) {
 590                         funcname_lno = cur;
 591                         funcname_needed = 0;
 592                 }
 593         }
 594
 595         /* We need to look even further back to find a function signature. */
 596         if (opt->funcname && funcname_needed)
 597                 show_funcname_line(opt, name, buf, bol, cur);
 598
 599         /* Back forward. */
 600         while (cur < lno) {
 601                 char *eol = bol, sign = (cur == funcname_lno) ? '=' : '-';
 602
 603                 while (*eol != '\n')
 604                         eol++;
 605                 show_line(opt, bol, eol, name, cur, sign);
 606                 bol = eol + 1;
 607                 cur++;
 608         }
 609 }
 610
 611 static int grep_buffer_1(struct grep_opt *opt, const char *name,
 612                          char *buf, unsigned long size, int collect_hits)
 613 {
 614         char *bol = buf;
 615         unsigned long left = size;
 616         unsigned lno = 1;
 617         unsigned last_hit = 0;
 618         int binary_match_only = 0;
 619         unsigned count = 0;
 620         enum grep_context ctx = GREP_CONTEXT_HEAD;
 621         xdemitconf_t xecfg;
 622
 623         opt->last_shown = 0;
 624
 625         if (buffer_is_binary(buf, size)) {
 626                 switch (opt->binary) {
 627                 case GREP_BINARY_DEFAULT:
 628                         binary_match_only = 1;
 629                         break;
 630                 case GREP_BINARY_NOMATCH:
 631                         return 0; /* Assume unmatch */
 632                         break;
 633                 default:
 634                         break;
 635                 }
 636         }
 637
 638         memset(&xecfg, 0, sizeof(xecfg));
 639         if (opt->funcname && !opt->unmatch_name_only && !opt->status_only &&
 640             !opt->name_only && !binary_match_only && !collect_hits) {
 641                 struct userdiff_driver *drv = userdiff_find_by_path(name);
 642                 if (drv && drv->funcname.pattern) {
 643                         const struct userdiff_funcname *pe = &drv->funcname;
 644                         xdiff_set_find_func(&xecfg, pe->pattern, pe->cflags);
 645                         opt->priv = &xecfg;
 646                 }
 647         }
 648
 649         while (left) {
 650                 char *eol, ch;
 651                 int hit;
 652
 653                 eol = end_of_line(bol, &left);
 654                 ch = *eol;
 655                 *eol = 0;
 656
 657                 if ((ctx == GREP_CONTEXT_HEAD) && (eol == bol))
 658                         ctx = GREP_CONTEXT_BODY;
 659
 660                 hit = match_line(opt, bol, eol, ctx, collect_hits);
 661                 *eol = ch;
 662
 663                 if (collect_hits)
 664                         goto next_line;
 665
 666                 /* "grep -v -e foo -e bla" should list lines
 667                  * that do not have either, so inversion should
 668                  * be done outside.
 669                  */
 670                 if (opt->invert)
 671                         hit = !hit;
 672                 if (opt->unmatch_name_only) {
 673                         if (hit)
 674                                 return 0;
 675                         goto next_line;
 676                 }
 677                 if (hit) {
 678                         count++;
 679                         if (opt->status_only)
 680                                 return 1;
 681                         if (binary_match_only) {
 682                                 printf("Binary file %s matches\n", name);
 683                                 return 1;
 684                         }
 685                         if (opt->name_only) {
 686                                 show_name(opt, name);
 687                                 return 1;
 688                         }
 689                         /* Hit at this line.  If we haven't shown the
 690                          * pre-context lines, we would need to show them.
 691                          * When asked to do "count", this still show
 692                          * the context which is nonsense, but the user
 693                          * deserves to get that ;-).
 694                          */
 695                         if (opt->pre_context)
 696                                 show_pre_context(opt, name, buf, bol, lno);
 697                         else if (opt->funcname)
 698                                 show_funcname_line(opt, name, buf, bol, lno);
 699                         if (!opt->count)
 700                                 show_line(opt, bol, eol, name, lno, ':');
 701                         last_hit = lno;
 702                 }
 703                 else if (last_hit &&
 704                          lno <= last_hit + opt->post_context) {
 705                         /* If the last hit is within the post context,
 706                          * we need to show this line.
 707                          */
 708                         show_line(opt, bol, eol, name, lno, '-');
 709                 }
 710
 711         next_line:
 712                 bol = eol + 1;
 713                 if (!left)
 714                         break;
 715                 left--;
 716                 lno++;
 717         }
 718
 719         if (collect_hits)
 720                 return 0;
 721
 722         if (opt->status_only)
 723                 return 0;
 724         if (opt->unmatch_name_only) {
 725                 /* We did not see any hit, so we want to show this */
 726                 show_name(opt, name);
 727                 return 1;
 728         }
 729
 730         xdiff_clear_find_func(&xecfg);
 731         opt->priv = NULL;
 732
 733         /* NEEDSWORK:
 734          * The real "grep -c foo *.c" gives many "bar.c:0" lines,
 735          * which feels mostly useless but sometimes useful.  Maybe
 736          * make it another option?  For now suppress them.
 737          */
 738         if (opt->count && count)
 739                 printf("%s%c%u\n", name,
 740                        opt->null_following_name ? '\0' : ':', count);
 741         return !!last_hit;
 742 }
 743
 744 static void clr_hit_marker(struct grep_expr *x)
 745 {
 746         /* All-hit markers are meaningful only at the very top level
 747          * OR node.
 748          */
 749         while (1) {
 750                 x->hit = 0;
 751                 if (x->node != GREP_NODE_OR)
 752                         return;
 753                 x->u.binary.left->hit = 0;
 754                 x = x->u.binary.right;
 755         }
 756 }
 757
 758 static int chk_hit_marker(struct grep_expr *x)
 759 {
 760         /* Top level nodes have hit markers.  See if they all are hits */
 761         while (1) {
 762                 if (x->node != GREP_NODE_OR)
 763                         return x->hit;
 764                 if (!x->u.binary.left->hit)
 765                         return 0;
 766                 x = x->u.binary.right;
 767         }
 768 }
 769
 770 int grep_buffer(struct grep_opt *opt, const char *name, char *buf, unsigned long size)
 771 {
 772         /*
 773          * we do not have to do the two-pass grep when we do not check
 774          * buffer-wide "all-match".
 775          */
 776         if (!opt->all_match)
 777                 return grep_buffer_1(opt, name, buf, size, 0);
 778
 779         /* Otherwise the toplevel "or" terms hit a bit differently.
 780          * We first clear hit markers from them.
 781          */
 782         clr_hit_marker(opt->pattern_expression);
 783         grep_buffer_1(opt, name, buf, size, 1);
 784
 785         if (!chk_hit_marker(opt->pattern_expression))
 786                 return 0;
 787
 788         return grep_buffer_1(opt, name, buf, size, 0);
 789 }