3 #include "xdiff-interface.h"
5 void append_header_grep_pattern(struct grep_opt
*opt
, enum grep_header_field field
, const char *pat
)
7 struct grep_pat
*p
= xcalloc(1, sizeof(*p
));
11 p
->token
= GREP_PATTERN_HEAD
;
13 *opt
->pattern_tail
= p
;
14 opt
->pattern_tail
= &p
->next
;
18 void append_grep_pattern(struct grep_opt
*opt
, const char *pat
,
19 const char *origin
, int no
, enum grep_pat_token t
)
21 struct grep_pat
*p
= xcalloc(1, sizeof(*p
));
26 *opt
->pattern_tail
= p
;
27 opt
->pattern_tail
= &p
->next
;
31 static int is_fixed(const char *s
)
33 while (*s
&& !is_regex_special(*s
))
38 static void compile_regexp(struct grep_pat
*p
, struct grep_opt
*opt
)
42 p
->word_regexp
= opt
->word_regexp
;
44 if (opt
->fixed
|| is_fixed(p
->pattern
))
46 if (opt
->regflags
& REG_ICASE
)
51 err
= regcomp(&p
->regexp
, p
->pattern
, opt
->regflags
);
56 sprintf(where
, "In '%s' at %d, ",
59 sprintf(where
, "%s, ", p
->origin
);
62 regerror(err
, &p
->regexp
, errbuf
, 1024);
64 die("%s'%s': %s", where
, p
->pattern
, errbuf
);
68 static struct grep_expr
*compile_pattern_or(struct grep_pat
**);
69 static struct grep_expr
*compile_pattern_atom(struct grep_pat
**list
)
76 case GREP_PATTERN
: /* atom */
77 case GREP_PATTERN_HEAD
:
78 case GREP_PATTERN_BODY
:
79 x
= xcalloc(1, sizeof (struct grep_expr
));
80 x
->node
= GREP_NODE_ATOM
;
86 x
= compile_pattern_or(list
);
89 if (!*list
|| (*list
)->token
!= GREP_CLOSE_PAREN
)
90 die("unmatched parenthesis");
91 *list
= (*list
)->next
;
98 static struct grep_expr
*compile_pattern_not(struct grep_pat
**list
)
107 die("--not not followed by pattern expression");
109 x
= xcalloc(1, sizeof (struct grep_expr
));
110 x
->node
= GREP_NODE_NOT
;
111 x
->u
.unary
= compile_pattern_not(list
);
113 die("--not followed by non pattern expression");
116 return compile_pattern_atom(list
);
120 static struct grep_expr
*compile_pattern_and(struct grep_pat
**list
)
123 struct grep_expr
*x
, *y
, *z
;
125 x
= compile_pattern_not(list
);
127 if (p
&& p
->token
== GREP_AND
) {
129 die("--and not followed by pattern expression");
131 y
= compile_pattern_and(list
);
133 die("--and not followed by pattern expression");
134 z
= xcalloc(1, sizeof (struct grep_expr
));
135 z
->node
= GREP_NODE_AND
;
136 z
->u
.binary
.left
= x
;
137 z
->u
.binary
.right
= y
;
143 static struct grep_expr
*compile_pattern_or(struct grep_pat
**list
)
146 struct grep_expr
*x
, *y
, *z
;
148 x
= compile_pattern_and(list
);
150 if (x
&& p
&& p
->token
!= GREP_CLOSE_PAREN
) {
151 y
= compile_pattern_or(list
);
153 die("not a pattern expression %s", p
->pattern
);
154 z
= xcalloc(1, sizeof (struct grep_expr
));
155 z
->node
= GREP_NODE_OR
;
156 z
->u
.binary
.left
= x
;
157 z
->u
.binary
.right
= y
;
163 static struct grep_expr
*compile_pattern_expr(struct grep_pat
**list
)
165 return compile_pattern_or(list
);
168 void compile_grep_patterns(struct grep_opt
*opt
)
175 for (p
= opt
->pattern_list
; p
; p
= p
->next
) {
177 case GREP_PATTERN
: /* atom */
178 case GREP_PATTERN_HEAD
:
179 case GREP_PATTERN_BODY
:
180 compile_regexp(p
, opt
);
191 /* Then bundle them up in an expression.
192 * A classic recursive descent parser would do.
194 p
= opt
->pattern_list
;
195 opt
->pattern_expression
= compile_pattern_expr(&p
);
197 die("incomplete pattern expression: %s", p
->pattern
);
200 static void free_pattern_expr(struct grep_expr
*x
)
206 free_pattern_expr(x
->u
.unary
);
210 free_pattern_expr(x
->u
.binary
.left
);
211 free_pattern_expr(x
->u
.binary
.right
);
217 void free_grep_patterns(struct grep_opt
*opt
)
219 struct grep_pat
*p
, *n
;
221 for (p
= opt
->pattern_list
; p
; p
= n
) {
224 case GREP_PATTERN
: /* atom */
225 case GREP_PATTERN_HEAD
:
226 case GREP_PATTERN_BODY
:
237 free_pattern_expr(opt
->pattern_expression
);
240 static char *end_of_line(char *cp
, unsigned long *left
)
242 unsigned long l
= *left
;
243 while (l
&& *cp
!= '\n') {
251 static int word_char(char ch
)
253 return isalnum(ch
) || ch
== '_';
256 static void show_line(struct grep_opt
*opt
, const char *bol
, const char *eol
,
257 const char *name
, unsigned lno
, char sign
)
259 if (opt
->null_following_name
)
262 printf("%s%c", name
, sign
);
264 printf("%d%c", lno
, sign
);
265 printf("%.*s\n", (int)(eol
-bol
), bol
);
268 static void show_name(struct grep_opt
*opt
, const char *name
)
270 printf("%s%c", name
, opt
->null_following_name
? '\0' : '\n');
273 static int fixmatch(const char *pattern
, char *line
, regmatch_t
*match
)
275 char *hit
= strstr(line
, pattern
);
277 match
->rm_so
= match
->rm_eo
= -1;
281 match
->rm_so
= hit
- line
;
282 match
->rm_eo
= match
->rm_so
+ strlen(pattern
);
287 static int strip_timestamp(char *bol
, char **eol_p
)
292 while (bol
< --eol
) {
308 { "committer ", 10 },
311 static int match_one_pattern(struct grep_pat
*p
, char *bol
, char *eol
,
312 enum grep_context ctx
,
313 regmatch_t
*pmatch
, int eflags
)
318 if ((p
->token
!= GREP_PATTERN
) &&
319 ((p
->token
== GREP_PATTERN_HEAD
) != (ctx
== GREP_CONTEXT_HEAD
)))
322 if (p
->token
== GREP_PATTERN_HEAD
) {
325 assert(p
->field
< ARRAY_SIZE(header_field
));
326 field
= header_field
[p
->field
].field
;
327 len
= header_field
[p
->field
].len
;
328 if (strncmp(bol
, field
, len
))
331 saved_ch
= strip_timestamp(bol
, &eol
);
336 hit
= !fixmatch(p
->pattern
, bol
, pmatch
);
338 hit
= !regexec(&p
->regexp
, bol
, 1, pmatch
, eflags
);
340 if (hit
&& p
->word_regexp
) {
341 if ((pmatch
[0].rm_so
< 0) ||
342 (eol
- bol
) <= pmatch
[0].rm_so
||
343 (pmatch
[0].rm_eo
< 0) ||
344 (eol
- bol
) < pmatch
[0].rm_eo
)
345 die("regexp returned nonsense");
347 /* Match beginning must be either beginning of the
348 * line, or at word boundary (i.e. the last char must
349 * not be a word char). Similarly, match end must be
350 * either end of the line, or at word boundary
351 * (i.e. the next char must not be a word char).
353 if ( ((pmatch
[0].rm_so
== 0) ||
354 !word_char(bol
[pmatch
[0].rm_so
-1])) &&
355 ((pmatch
[0].rm_eo
== (eol
-bol
)) ||
356 !word_char(bol
[pmatch
[0].rm_eo
])) )
361 if (!hit
&& pmatch
[0].rm_so
+ bol
+ 1 < eol
) {
362 /* There could be more than one match on the
363 * line, and the first match might not be
364 * strict word match. But later ones could be!
365 * Forward to the next possible start, i.e. the
366 * next position following a non-word char.
368 bol
= pmatch
[0].rm_so
+ bol
+ 1;
369 while (word_char(bol
[-1]) && bol
< eol
)
375 if (p
->token
== GREP_PATTERN_HEAD
&& saved_ch
)
380 static int match_expr_eval(struct grep_expr
*x
, char *bol
, char *eol
,
381 enum grep_context ctx
, int collect_hits
)
388 h
= match_one_pattern(x
->u
.atom
, bol
, eol
, ctx
, &match
, 0);
391 h
= !match_expr_eval(x
->u
.unary
, bol
, eol
, ctx
, 0);
394 if (!match_expr_eval(x
->u
.binary
.left
, bol
, eol
, ctx
, 0))
396 h
= match_expr_eval(x
->u
.binary
.right
, bol
, eol
, ctx
, 0);
400 return (match_expr_eval(x
->u
.binary
.left
,
402 match_expr_eval(x
->u
.binary
.right
,
404 h
= match_expr_eval(x
->u
.binary
.left
, bol
, eol
, ctx
, 0);
405 x
->u
.binary
.left
->hit
|= h
;
406 h
|= match_expr_eval(x
->u
.binary
.right
, bol
, eol
, ctx
, 1);
409 die("Unexpected node type (internal error) %d", x
->node
);
416 static int match_expr(struct grep_opt
*opt
, char *bol
, char *eol
,
417 enum grep_context ctx
, int collect_hits
)
419 struct grep_expr
*x
= opt
->pattern_expression
;
420 return match_expr_eval(x
, bol
, eol
, ctx
, collect_hits
);
423 static int match_line(struct grep_opt
*opt
, char *bol
, char *eol
,
424 enum grep_context ctx
, int collect_hits
)
430 return match_expr(opt
, bol
, eol
, ctx
, collect_hits
);
432 /* we do not call with collect_hits without being extended */
433 for (p
= opt
->pattern_list
; p
; p
= p
->next
) {
434 if (match_one_pattern(p
, bol
, eol
, ctx
, &match
, 0))
440 static int grep_buffer_1(struct grep_opt
*opt
, const char *name
,
441 char *buf
, unsigned long size
, int collect_hits
)
444 unsigned long left
= size
;
446 struct pre_context_line
{
449 } *prev
= NULL
, *pcl
;
450 unsigned last_hit
= 0;
451 unsigned last_shown
= 0;
452 int binary_match_only
= 0;
453 const char *hunk_mark
= "";
455 enum grep_context ctx
= GREP_CONTEXT_HEAD
;
457 if (buffer_is_binary(buf
, size
)) {
458 switch (opt
->binary
) {
459 case GREP_BINARY_DEFAULT
:
460 binary_match_only
= 1;
462 case GREP_BINARY_NOMATCH
:
463 return 0; /* Assume unmatch */
470 if (opt
->pre_context
)
471 prev
= xcalloc(opt
->pre_context
, sizeof(*prev
));
472 if (opt
->pre_context
|| opt
->post_context
)
479 eol
= end_of_line(bol
, &left
);
483 if ((ctx
== GREP_CONTEXT_HEAD
) && (eol
== bol
))
484 ctx
= GREP_CONTEXT_BODY
;
486 hit
= match_line(opt
, bol
, eol
, ctx
, collect_hits
);
492 /* "grep -v -e foo -e bla" should list lines
493 * that do not have either, so inversion should
498 if (opt
->unmatch_name_only
) {
505 if (opt
->status_only
)
507 if (binary_match_only
) {
508 printf("Binary file %s matches\n", name
);
511 if (opt
->name_only
) {
512 show_name(opt
, name
);
515 /* Hit at this line. If we haven't shown the
516 * pre-context lines, we would need to show them.
517 * When asked to do "count", this still show
518 * the context which is nonsense, but the user
519 * deserves to get that ;-).
521 if (opt
->pre_context
) {
523 if (opt
->pre_context
< lno
)
524 from
= lno
- opt
->pre_context
;
527 if (from
<= last_shown
)
528 from
= last_shown
+ 1;
529 if (last_shown
&& from
!= last_shown
+ 1)
530 fputs(hunk_mark
, stdout
);
532 pcl
= &prev
[lno
-from
-1];
533 show_line(opt
, pcl
->bol
, pcl
->eol
,
539 if (last_shown
&& lno
!= last_shown
+ 1)
540 fputs(hunk_mark
, stdout
);
542 show_line(opt
, bol
, eol
, name
, lno
, ':');
543 last_shown
= last_hit
= lno
;
546 lno
<= last_hit
+ opt
->post_context
) {
547 /* If the last hit is within the post context,
548 * we need to show this line.
550 if (last_shown
&& lno
!= last_shown
+ 1)
551 fputs(hunk_mark
, stdout
);
552 show_line(opt
, bol
, eol
, name
, lno
, '-');
555 if (opt
->pre_context
) {
556 memmove(prev
+1, prev
,
557 (opt
->pre_context
-1) * sizeof(*prev
));
574 if (opt
->status_only
)
576 if (opt
->unmatch_name_only
) {
577 /* We did not see any hit, so we want to show this */
578 show_name(opt
, name
);
583 * The real "grep -c foo *.c" gives many "bar.c:0" lines,
584 * which feels mostly useless but sometimes useful. Maybe
585 * make it another option? For now suppress them.
587 if (opt
->count
&& count
)
588 printf("%s%c%u\n", name
,
589 opt
->null_following_name
? '\0' : ':', count
);
593 static void clr_hit_marker(struct grep_expr
*x
)
595 /* All-hit markers are meaningful only at the very top level
600 if (x
->node
!= GREP_NODE_OR
)
602 x
->u
.binary
.left
->hit
= 0;
603 x
= x
->u
.binary
.right
;
607 static int chk_hit_marker(struct grep_expr
*x
)
609 /* Top level nodes have hit markers. See if they all are hits */
611 if (x
->node
!= GREP_NODE_OR
)
613 if (!x
->u
.binary
.left
->hit
)
615 x
= x
->u
.binary
.right
;
619 int grep_buffer(struct grep_opt
*opt
, const char *name
, char *buf
, unsigned long size
)
622 * we do not have to do the two-pass grep when we do not check
623 * buffer-wide "all-match".
626 return grep_buffer_1(opt
, name
, buf
, size
, 0);
628 /* Otherwise the toplevel "or" terms hit a bit differently.
629 * We first clear hit markers from them.
631 clr_hit_marker(opt
->pattern_expression
);
632 grep_buffer_1(opt
, name
, buf
, size
, 1);
634 if (!chk_hit_marker(opt
->pattern_expression
))
637 return grep_buffer_1(opt
, name
, buf
, size
, 0);