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