Merge branch 'tr/maint-roff-quote'
[git] / 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 }