[821] | 1 | /* vi: set sw=4 ts=4: */
|
---|
| 2 | /*
|
---|
| 3 | * Mini grep implementation for busybox using libc regex.
|
---|
| 4 | *
|
---|
| 5 | * Copyright (C) 1999,2000,2001 by Lineo, inc. and Mark Whitley
|
---|
| 6 | * Copyright (C) 1999,2000,2001 by Mark Whitley <markw@codepoet.org>
|
---|
| 7 | *
|
---|
[2725] | 8 | * Licensed under GPLv2 or later, see file LICENSE in this source tree.
|
---|
[821] | 9 | */
|
---|
[2725] | 10 | /* BB_AUDIT SUSv3 defects - unsupported option -x "match whole line only". */
|
---|
[821] | 11 | /* BB_AUDIT GNU defects - always acts as -a. */
|
---|
| 12 | /* http://www.opengroup.org/onlinepubs/007904975/utilities/grep.html */
|
---|
| 13 | /*
|
---|
| 14 | * 2004,2006 (C) Vladimir Oleynik <dzo@simtreas.ru> -
|
---|
| 15 | * correction "-e pattern1 -e pattern2" logic and more optimizations.
|
---|
| 16 | * precompiled regex
|
---|
[2725] | 17 | *
|
---|
[1765] | 18 | * (C) 2006 Jac Goudsmit added -o option
|
---|
| 19 | */
|
---|
[821] | 20 |
|
---|
[3232] | 21 | //applet:IF_GREP(APPLET(grep, BB_DIR_BIN, BB_SUID_DROP))
|
---|
| 22 | //applet:IF_FEATURE_GREP_EGREP_ALIAS(APPLET_ODDNAME(egrep, grep, BB_DIR_BIN, BB_SUID_DROP, egrep))
|
---|
| 23 | //applet:IF_FEATURE_GREP_FGREP_ALIAS(APPLET_ODDNAME(fgrep, grep, BB_DIR_BIN, BB_SUID_DROP, fgrep))
|
---|
[2725] | 24 |
|
---|
| 25 | //kbuild:lib-$(CONFIG_GREP) += grep.o
|
---|
| 26 |
|
---|
| 27 | //config:config GREP
|
---|
| 28 | //config: bool "grep"
|
---|
| 29 | //config: default y
|
---|
| 30 | //config: help
|
---|
| 31 | //config: grep is used to search files for a specified pattern.
|
---|
| 32 | //config:
|
---|
| 33 | //config:config FEATURE_GREP_EGREP_ALIAS
|
---|
| 34 | //config: bool "Enable extended regular expressions (egrep & grep -E)"
|
---|
| 35 | //config: default y
|
---|
| 36 | //config: depends on GREP
|
---|
| 37 | //config: help
|
---|
| 38 | //config: Enabled support for extended regular expressions. Extended
|
---|
| 39 | //config: regular expressions allow for alternation (foo|bar), grouping,
|
---|
| 40 | //config: and various repetition operators.
|
---|
| 41 | //config:
|
---|
| 42 | //config:config FEATURE_GREP_FGREP_ALIAS
|
---|
| 43 | //config: bool "Alias fgrep to grep -F"
|
---|
| 44 | //config: default y
|
---|
| 45 | //config: depends on GREP
|
---|
| 46 | //config: help
|
---|
| 47 | //config: fgrep sees the search pattern as a normal string rather than
|
---|
| 48 | //config: regular expressions.
|
---|
| 49 | //config: grep -F always works, this just creates the fgrep alias.
|
---|
| 50 | //config:
|
---|
| 51 | //config:config FEATURE_GREP_CONTEXT
|
---|
| 52 | //config: bool "Enable before and after context flags (-A, -B and -C)"
|
---|
| 53 | //config: default y
|
---|
| 54 | //config: depends on GREP
|
---|
| 55 | //config: help
|
---|
| 56 | //config: Print the specified number of leading (-B) and/or trailing (-A)
|
---|
| 57 | //config: context surrounding our matching lines.
|
---|
| 58 | //config: Print the specified number of context lines (-C).
|
---|
| 59 |
|
---|
[1765] | 60 | #include "libbb.h"
|
---|
[821] | 61 | #include "xregex.h"
|
---|
| 62 |
|
---|
[2725] | 63 |
|
---|
[821] | 64 | /* options */
|
---|
[2725] | 65 | //usage:#define grep_trivial_usage
|
---|
| 66 | //usage: "[-HhnlLoqvsriw"
|
---|
| 67 | //usage: "F"
|
---|
| 68 | //usage: IF_FEATURE_GREP_EGREP_ALIAS("E")
|
---|
| 69 | //usage: IF_EXTRA_COMPAT("z")
|
---|
| 70 | //usage: "] [-m N] "
|
---|
| 71 | //usage: IF_FEATURE_GREP_CONTEXT("[-A/B/C N] ")
|
---|
| 72 | //usage: "PATTERN/-e PATTERN.../-f FILE [FILE]..."
|
---|
| 73 | //usage:#define grep_full_usage "\n\n"
|
---|
| 74 | //usage: "Search for PATTERN in FILEs (or stdin)\n"
|
---|
| 75 | //usage: "\n -H Add 'filename:' prefix"
|
---|
| 76 | //usage: "\n -h Do not add 'filename:' prefix"
|
---|
| 77 | //usage: "\n -n Add 'line_no:' prefix"
|
---|
| 78 | //usage: "\n -l Show only names of files that match"
|
---|
| 79 | //usage: "\n -L Show only names of files that don't match"
|
---|
| 80 | //usage: "\n -c Show only count of matching lines"
|
---|
| 81 | //usage: "\n -o Show only the matching part of line"
|
---|
| 82 | //usage: "\n -q Quiet. Return 0 if PATTERN is found, 1 otherwise"
|
---|
| 83 | //usage: "\n -v Select non-matching lines"
|
---|
| 84 | //usage: "\n -s Suppress open and read errors"
|
---|
| 85 | //usage: "\n -r Recurse"
|
---|
| 86 | //usage: "\n -i Ignore case"
|
---|
| 87 | //usage: "\n -w Match whole words only"
|
---|
[3232] | 88 | //usage: "\n -x Match whole lines only"
|
---|
[2725] | 89 | //usage: "\n -F PATTERN is a literal (not regexp)"
|
---|
| 90 | //usage: IF_FEATURE_GREP_EGREP_ALIAS(
|
---|
| 91 | //usage: "\n -E PATTERN is an extended regexp"
|
---|
| 92 | //usage: )
|
---|
| 93 | //usage: IF_EXTRA_COMPAT(
|
---|
| 94 | //usage: "\n -z Input is NUL terminated"
|
---|
| 95 | //usage: )
|
---|
| 96 | //usage: "\n -m N Match up to N times per file"
|
---|
| 97 | //usage: IF_FEATURE_GREP_CONTEXT(
|
---|
| 98 | //usage: "\n -A N Print N lines of trailing context"
|
---|
| 99 | //usage: "\n -B N Print N lines of leading context"
|
---|
| 100 | //usage: "\n -C N Same as '-A N -B N'"
|
---|
| 101 | //usage: )
|
---|
| 102 | //usage: "\n -e PTRN Pattern to match"
|
---|
| 103 | //usage: "\n -f FILE Read pattern from file"
|
---|
| 104 | //usage:
|
---|
| 105 | //usage:#define grep_example_usage
|
---|
| 106 | //usage: "$ grep root /etc/passwd\n"
|
---|
| 107 | //usage: "root:x:0:0:root:/root:/bin/bash\n"
|
---|
| 108 | //usage: "$ grep ^[rR]oo. /etc/passwd\n"
|
---|
| 109 | //usage: "root:x:0:0:root:/root:/bin/bash\n"
|
---|
| 110 | //usage:
|
---|
| 111 | //usage:#define egrep_trivial_usage NOUSAGE_STR
|
---|
| 112 | //usage:#define egrep_full_usage ""
|
---|
| 113 | //usage:#define fgrep_trivial_usage NOUSAGE_STR
|
---|
| 114 | //usage:#define fgrep_full_usage ""
|
---|
| 115 |
|
---|
[1765] | 116 | #define OPTSTR_GREP \
|
---|
[3232] | 117 | "lnqvscFiHhe:f:Lorm:wx" \
|
---|
[2725] | 118 | IF_FEATURE_GREP_CONTEXT("A:B:C:") \
|
---|
| 119 | IF_FEATURE_GREP_EGREP_ALIAS("E") \
|
---|
| 120 | IF_EXTRA_COMPAT("z") \
|
---|
[1765] | 121 | "aI"
|
---|
| 122 | /* ignored: -a "assume all files to be text" */
|
---|
| 123 | /* ignored: -I "assume binary files have no matches" */
|
---|
| 124 | enum {
|
---|
| 125 | OPTBIT_l, /* list matched file names only */
|
---|
| 126 | OPTBIT_n, /* print line# */
|
---|
[2725] | 127 | OPTBIT_q, /* quiet - exit(EXIT_SUCCESS) of first match */
|
---|
[1765] | 128 | OPTBIT_v, /* invert the match, to select non-matching lines */
|
---|
| 129 | OPTBIT_s, /* suppress errors about file open errors */
|
---|
| 130 | OPTBIT_c, /* count matches per file (suppresses normal output) */
|
---|
| 131 | OPTBIT_F, /* literal match */
|
---|
| 132 | OPTBIT_i, /* case-insensitive */
|
---|
| 133 | OPTBIT_H, /* force filename display */
|
---|
| 134 | OPTBIT_h, /* inhibit filename display */
|
---|
| 135 | OPTBIT_e, /* -e PATTERN */
|
---|
| 136 | OPTBIT_f, /* -f FILE_WITH_PATTERNS */
|
---|
| 137 | OPTBIT_L, /* list unmatched file names only */
|
---|
| 138 | OPTBIT_o, /* show only matching parts of lines */
|
---|
| 139 | OPTBIT_r, /* recurse dirs */
|
---|
| 140 | OPTBIT_m, /* -m MAX_MATCHES */
|
---|
[2725] | 141 | OPTBIT_w, /* -w whole word match */
|
---|
[3232] | 142 | OPTBIT_x, /* -x whole line match */
|
---|
[2725] | 143 | IF_FEATURE_GREP_CONTEXT( OPTBIT_A ,) /* -A NUM: after-match context */
|
---|
| 144 | IF_FEATURE_GREP_CONTEXT( OPTBIT_B ,) /* -B NUM: before-match context */
|
---|
| 145 | IF_FEATURE_GREP_CONTEXT( OPTBIT_C ,) /* -C NUM: -A and -B combined */
|
---|
| 146 | IF_FEATURE_GREP_EGREP_ALIAS(OPTBIT_E ,) /* extended regexp */
|
---|
| 147 | IF_EXTRA_COMPAT( OPTBIT_z ,) /* input is NUL terminated */
|
---|
[1765] | 148 | OPT_l = 1 << OPTBIT_l,
|
---|
| 149 | OPT_n = 1 << OPTBIT_n,
|
---|
| 150 | OPT_q = 1 << OPTBIT_q,
|
---|
| 151 | OPT_v = 1 << OPTBIT_v,
|
---|
| 152 | OPT_s = 1 << OPTBIT_s,
|
---|
| 153 | OPT_c = 1 << OPTBIT_c,
|
---|
| 154 | OPT_F = 1 << OPTBIT_F,
|
---|
| 155 | OPT_i = 1 << OPTBIT_i,
|
---|
| 156 | OPT_H = 1 << OPTBIT_H,
|
---|
| 157 | OPT_h = 1 << OPTBIT_h,
|
---|
| 158 | OPT_e = 1 << OPTBIT_e,
|
---|
| 159 | OPT_f = 1 << OPTBIT_f,
|
---|
| 160 | OPT_L = 1 << OPTBIT_L,
|
---|
| 161 | OPT_o = 1 << OPTBIT_o,
|
---|
| 162 | OPT_r = 1 << OPTBIT_r,
|
---|
| 163 | OPT_m = 1 << OPTBIT_m,
|
---|
[2725] | 164 | OPT_w = 1 << OPTBIT_w,
|
---|
[3232] | 165 | OPT_x = 1 << OPTBIT_x,
|
---|
[2725] | 166 | OPT_A = IF_FEATURE_GREP_CONTEXT( (1 << OPTBIT_A)) + 0,
|
---|
| 167 | OPT_B = IF_FEATURE_GREP_CONTEXT( (1 << OPTBIT_B)) + 0,
|
---|
| 168 | OPT_C = IF_FEATURE_GREP_CONTEXT( (1 << OPTBIT_C)) + 0,
|
---|
| 169 | OPT_E = IF_FEATURE_GREP_EGREP_ALIAS((1 << OPTBIT_E)) + 0,
|
---|
| 170 | OPT_z = IF_EXTRA_COMPAT( (1 << OPTBIT_z)) + 0,
|
---|
[1765] | 171 | };
|
---|
| 172 |
|
---|
| 173 | #define PRINT_FILES_WITH_MATCHES (option_mask32 & OPT_l)
|
---|
| 174 | #define PRINT_LINE_NUM (option_mask32 & OPT_n)
|
---|
| 175 | #define BE_QUIET (option_mask32 & OPT_q)
|
---|
| 176 | #define SUPPRESS_ERR_MSGS (option_mask32 & OPT_s)
|
---|
| 177 | #define PRINT_MATCH_COUNTS (option_mask32 & OPT_c)
|
---|
| 178 | #define FGREP_FLAG (option_mask32 & OPT_F)
|
---|
| 179 | #define PRINT_FILES_WITHOUT_MATCHES (option_mask32 & OPT_L)
|
---|
[2725] | 180 | #define NUL_DELIMITED (option_mask32 & OPT_z)
|
---|
[1765] | 181 |
|
---|
[2725] | 182 | struct globals {
|
---|
| 183 | int max_matches;
|
---|
| 184 | #if !ENABLE_EXTRA_COMPAT
|
---|
| 185 | int reflags;
|
---|
| 186 | #else
|
---|
| 187 | RE_TRANSLATE_TYPE case_fold; /* RE_TRANSLATE_TYPE is [[un]signed] char* */
|
---|
| 188 | #endif
|
---|
| 189 | smalluint invert_search;
|
---|
| 190 | smalluint print_filename;
|
---|
| 191 | smalluint open_errors;
|
---|
| 192 | #if ENABLE_FEATURE_GREP_CONTEXT
|
---|
| 193 | smalluint did_print_line;
|
---|
| 194 | int lines_before;
|
---|
| 195 | int lines_after;
|
---|
| 196 | char **before_buf;
|
---|
| 197 | IF_EXTRA_COMPAT(size_t *before_buf_size;)
|
---|
| 198 | int last_line_printed;
|
---|
| 199 | #endif
|
---|
| 200 | /* globals used internally */
|
---|
| 201 | llist_t *pattern_head; /* growable list of patterns to match */
|
---|
| 202 | const char *cur_file; /* the current file we are reading */
|
---|
| 203 | } FIX_ALIASING;
|
---|
| 204 | #define G (*(struct globals*)&bb_common_bufsiz1)
|
---|
| 205 | #define INIT_G() do { \
|
---|
| 206 | struct G_sizecheck { \
|
---|
| 207 | char G_sizecheck[sizeof(G) > COMMON_BUFSIZE ? -1 : 1]; \
|
---|
| 208 | }; \
|
---|
| 209 | } while (0)
|
---|
| 210 | #define max_matches (G.max_matches )
|
---|
| 211 | #if !ENABLE_EXTRA_COMPAT
|
---|
| 212 | # define reflags (G.reflags )
|
---|
| 213 | #else
|
---|
| 214 | # define case_fold (G.case_fold )
|
---|
| 215 | /* http://www.delorie.com/gnu/docs/regex/regex_46.html */
|
---|
| 216 | # define reflags re_syntax_options
|
---|
| 217 | # undef REG_NOSUB
|
---|
| 218 | # undef REG_EXTENDED
|
---|
| 219 | # undef REG_ICASE
|
---|
| 220 | # define REG_NOSUB bug:is:here /* should not be used */
|
---|
| 221 | /* Just RE_SYNTAX_EGREP is not enough, need to enable {n[,[m]]} too */
|
---|
| 222 | # define REG_EXTENDED (RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES)
|
---|
| 223 | # define REG_ICASE bug:is:here /* should not be used */
|
---|
| 224 | #endif
|
---|
| 225 | #define invert_search (G.invert_search )
|
---|
| 226 | #define print_filename (G.print_filename )
|
---|
| 227 | #define open_errors (G.open_errors )
|
---|
| 228 | #define did_print_line (G.did_print_line )
|
---|
| 229 | #define lines_before (G.lines_before )
|
---|
| 230 | #define lines_after (G.lines_after )
|
---|
| 231 | #define before_buf (G.before_buf )
|
---|
| 232 | #define before_buf_size (G.before_buf_size )
|
---|
| 233 | #define last_line_printed (G.last_line_printed )
|
---|
| 234 | #define pattern_head (G.pattern_head )
|
---|
| 235 | #define cur_file (G.cur_file )
|
---|
[1765] | 236 |
|
---|
[821] | 237 |
|
---|
[1765] | 238 | typedef struct grep_list_data_t {
|
---|
[821] | 239 | char *pattern;
|
---|
[2725] | 240 | /* for GNU regex, matched_range must be persistent across grep_file() calls */
|
---|
| 241 | #if !ENABLE_EXTRA_COMPAT
|
---|
| 242 | regex_t compiled_regex;
|
---|
| 243 | regmatch_t matched_range;
|
---|
| 244 | #else
|
---|
| 245 | struct re_pattern_buffer compiled_regex;
|
---|
| 246 | struct re_registers matched_range;
|
---|
| 247 | #endif
|
---|
| 248 | #define ALLOCATED 1
|
---|
[821] | 249 | #define COMPILED 2
|
---|
| 250 | int flg_mem_alocated_compiled;
|
---|
| 251 | } grep_list_data_t;
|
---|
| 252 |
|
---|
[2725] | 253 | #if !ENABLE_EXTRA_COMPAT
|
---|
| 254 | #define print_line(line, line_len, linenum, decoration) \
|
---|
| 255 | print_line(line, linenum, decoration)
|
---|
| 256 | #endif
|
---|
| 257 | static void print_line(const char *line, size_t line_len, int linenum, char decoration)
|
---|
[821] | 258 | {
|
---|
| 259 | #if ENABLE_FEATURE_GREP_CONTEXT
|
---|
[1765] | 260 | /* Happens when we go to next file, immediately hit match
|
---|
| 261 | * and try to print prev context... from prev file! Don't do it */
|
---|
| 262 | if (linenum < 1)
|
---|
| 263 | return;
|
---|
[821] | 264 | /* possibly print the little '--' separator */
|
---|
[2725] | 265 | if ((lines_before || lines_after) && did_print_line
|
---|
| 266 | && last_line_printed != linenum - 1
|
---|
| 267 | ) {
|
---|
[821] | 268 | puts("--");
|
---|
| 269 | }
|
---|
[1765] | 270 | /* guard against printing "--" before first line of first file */
|
---|
| 271 | did_print_line = 1;
|
---|
[821] | 272 | last_line_printed = linenum;
|
---|
| 273 | #endif
|
---|
[1765] | 274 | if (print_filename)
|
---|
[821] | 275 | printf("%s%c", cur_file, decoration);
|
---|
| 276 | if (PRINT_LINE_NUM)
|
---|
| 277 | printf("%i%c", linenum, decoration);
|
---|
[1765] | 278 | /* Emulate weird GNU grep behavior with -ov */
|
---|
[2725] | 279 | if ((option_mask32 & (OPT_v|OPT_o)) != (OPT_v|OPT_o)) {
|
---|
| 280 | #if !ENABLE_EXTRA_COMPAT
|
---|
[1765] | 281 | puts(line);
|
---|
[2725] | 282 | #else
|
---|
| 283 | fwrite(line, 1, line_len, stdout);
|
---|
| 284 | putchar(NUL_DELIMITED ? '\0' : '\n');
|
---|
| 285 | #endif
|
---|
| 286 | }
|
---|
[821] | 287 | }
|
---|
| 288 |
|
---|
[2725] | 289 | #if ENABLE_EXTRA_COMPAT
|
---|
| 290 | /* Unlike getline, this one removes trailing '\n' */
|
---|
| 291 | static ssize_t FAST_FUNC bb_getline(char **line_ptr, size_t *line_alloc_len, FILE *file)
|
---|
| 292 | {
|
---|
| 293 | ssize_t res_sz;
|
---|
| 294 | char *line;
|
---|
| 295 | int delim = (NUL_DELIMITED ? '\0' : '\n');
|
---|
| 296 |
|
---|
| 297 | res_sz = getdelim(line_ptr, line_alloc_len, delim, file);
|
---|
| 298 | line = *line_ptr;
|
---|
| 299 |
|
---|
| 300 | if (res_sz > 0) {
|
---|
| 301 | if (line[res_sz - 1] == delim)
|
---|
| 302 | line[--res_sz] = '\0';
|
---|
| 303 | } else {
|
---|
| 304 | free(line); /* uclibc allocates a buffer even on EOF. WTF? */
|
---|
| 305 | }
|
---|
| 306 | return res_sz;
|
---|
| 307 | }
|
---|
| 308 | #endif
|
---|
| 309 |
|
---|
[821] | 310 | static int grep_file(FILE *file)
|
---|
| 311 | {
|
---|
[2725] | 312 | smalluint found;
|
---|
[821] | 313 | int linenum = 0;
|
---|
| 314 | int nmatches = 0;
|
---|
[2725] | 315 | #if !ENABLE_EXTRA_COMPAT
|
---|
| 316 | char *line;
|
---|
| 317 | #else
|
---|
| 318 | char *line = NULL;
|
---|
| 319 | ssize_t line_len;
|
---|
| 320 | size_t line_alloc_len;
|
---|
| 321 | # define rm_so start[0]
|
---|
| 322 | # define rm_eo end[0]
|
---|
| 323 | #endif
|
---|
[821] | 324 | #if ENABLE_FEATURE_GREP_CONTEXT
|
---|
| 325 | int print_n_lines_after = 0;
|
---|
| 326 | int curpos = 0; /* track where we are in the circular 'before' buffer */
|
---|
| 327 | int idx = 0; /* used for iteration through the circular buffer */
|
---|
[1765] | 328 | #else
|
---|
| 329 | enum { print_n_lines_after = 0 };
|
---|
[2725] | 330 | #endif
|
---|
[821] | 331 |
|
---|
[2725] | 332 | while (
|
---|
| 333 | #if !ENABLE_EXTRA_COMPAT
|
---|
| 334 | (line = xmalloc_fgetline(file)) != NULL
|
---|
| 335 | #else
|
---|
| 336 | (line_len = bb_getline(&line, &line_alloc_len, file)) >= 0
|
---|
| 337 | #endif
|
---|
| 338 | ) {
|
---|
[821] | 339 | llist_t *pattern_ptr = pattern_head;
|
---|
[2725] | 340 | grep_list_data_t *gl = gl; /* for gcc */
|
---|
[821] | 341 |
|
---|
| 342 | linenum++;
|
---|
[2725] | 343 | found = 0;
|
---|
[821] | 344 | while (pattern_ptr) {
|
---|
| 345 | gl = (grep_list_data_t *)pattern_ptr->data;
|
---|
| 346 | if (FGREP_FLAG) {
|
---|
[3232] | 347 | char *match;
|
---|
| 348 | char *str = line;
|
---|
| 349 | opt_f_again:
|
---|
| 350 | match = ((option_mask32 & OPT_i)
|
---|
| 351 | ? strcasestr(str, gl->pattern)
|
---|
| 352 | : strstr(str, gl->pattern)
|
---|
| 353 | );
|
---|
| 354 | if (match) {
|
---|
| 355 | if (option_mask32 & OPT_x) {
|
---|
| 356 | if (match != str)
|
---|
| 357 | goto opt_f_not_found;
|
---|
| 358 | if (str[strlen(gl->pattern)] != '\0')
|
---|
| 359 | goto opt_f_not_found;
|
---|
| 360 | } else
|
---|
| 361 | if (option_mask32 & OPT_w) {
|
---|
| 362 | char c = (match != str) ? match[-1] : ' ';
|
---|
| 363 | if (!isalnum(c) && c != '_') {
|
---|
| 364 | c = match[strlen(gl->pattern)];
|
---|
| 365 | if (!c || (!isalnum(c) && c != '_'))
|
---|
| 366 | goto opt_f_found;
|
---|
| 367 | }
|
---|
| 368 | str = match + 1;
|
---|
| 369 | goto opt_f_again;
|
---|
| 370 | }
|
---|
| 371 | opt_f_found:
|
---|
| 372 | found = 1;
|
---|
| 373 | opt_f_not_found: ;
|
---|
| 374 | }
|
---|
[821] | 375 | } else {
|
---|
[1765] | 376 | if (!(gl->flg_mem_alocated_compiled & COMPILED)) {
|
---|
[821] | 377 | gl->flg_mem_alocated_compiled |= COMPILED;
|
---|
[2725] | 378 | #if !ENABLE_EXTRA_COMPAT
|
---|
| 379 | xregcomp(&gl->compiled_regex, gl->pattern, reflags);
|
---|
| 380 | #else
|
---|
| 381 | memset(&gl->compiled_regex, 0, sizeof(gl->compiled_regex));
|
---|
| 382 | gl->compiled_regex.translate = case_fold; /* for -i */
|
---|
| 383 | if (re_compile_pattern(gl->pattern, strlen(gl->pattern), &gl->compiled_regex))
|
---|
| 384 | bb_error_msg_and_die("bad regex '%s'", gl->pattern);
|
---|
| 385 | #endif
|
---|
[821] | 386 | }
|
---|
[2725] | 387 | #if !ENABLE_EXTRA_COMPAT
|
---|
| 388 | gl->matched_range.rm_so = 0;
|
---|
| 389 | gl->matched_range.rm_eo = 0;
|
---|
| 390 | #endif
|
---|
| 391 | if (
|
---|
| 392 | #if !ENABLE_EXTRA_COMPAT
|
---|
| 393 | regexec(&gl->compiled_regex, line, 1, &gl->matched_range, 0) == 0
|
---|
| 394 | #else
|
---|
| 395 | re_search(&gl->compiled_regex, line, line_len,
|
---|
| 396 | /*start:*/ 0, /*range:*/ line_len,
|
---|
| 397 | &gl->matched_range) >= 0
|
---|
| 398 | #endif
|
---|
| 399 | ) {
|
---|
[3232] | 400 | if (option_mask32 & OPT_x) {
|
---|
| 401 | found = (gl->matched_range.rm_so == 0
|
---|
| 402 | && line[gl->matched_range.rm_eo] == '\0');
|
---|
| 403 | } else
|
---|
| 404 | if (!(option_mask32 & OPT_w)) {
|
---|
[2725] | 405 | found = 1;
|
---|
[3232] | 406 | } else {
|
---|
[1765] | 407 | char c = ' ';
|
---|
[2725] | 408 | if (gl->matched_range.rm_so)
|
---|
| 409 | c = line[gl->matched_range.rm_so - 1];
|
---|
[1765] | 410 | if (!isalnum(c) && c != '_') {
|
---|
[2725] | 411 | c = line[gl->matched_range.rm_eo];
|
---|
[1765] | 412 | if (!c || (!isalnum(c) && c != '_'))
|
---|
[2725] | 413 | found = 1;
|
---|
[1765] | 414 | }
|
---|
[3232] | 415 | //BUG: "echo foop foo | grep -w foo" should match, but doesn't:
|
---|
| 416 | //we bail out on first "mismatch" because it's not a word.
|
---|
[1765] | 417 | }
|
---|
| 418 | }
|
---|
[821] | 419 | }
|
---|
[2725] | 420 | /* If it's non-inverted search, we can stop
|
---|
| 421 | * at first match */
|
---|
| 422 | if (found && !invert_search)
|
---|
| 423 | goto do_found;
|
---|
[821] | 424 | pattern_ptr = pattern_ptr->link;
|
---|
| 425 | } /* while (pattern_ptr) */
|
---|
| 426 |
|
---|
[2725] | 427 | if (found ^ invert_search) {
|
---|
| 428 | do_found:
|
---|
[1765] | 429 | /* keep track of matches */
|
---|
| 430 | nmatches++;
|
---|
[821] | 431 |
|
---|
[1765] | 432 | /* quiet/print (non)matching file names only? */
|
---|
| 433 | if (option_mask32 & (OPT_q|OPT_l|OPT_L)) {
|
---|
| 434 | free(line); /* we don't need line anymore */
|
---|
| 435 | if (BE_QUIET) {
|
---|
| 436 | /* manpage says about -q:
|
---|
| 437 | * "exit immediately with zero status
|
---|
| 438 | * if any match is found,
|
---|
| 439 | * even if errors were detected" */
|
---|
[2725] | 440 | exit(EXIT_SUCCESS);
|
---|
[1765] | 441 | }
|
---|
[821] | 442 | /* if we're just printing filenames, we stop after the first match */
|
---|
[1765] | 443 | if (PRINT_FILES_WITH_MATCHES) {
|
---|
| 444 | puts(cur_file);
|
---|
[2725] | 445 | /* fall through to "return 1" */
|
---|
[1765] | 446 | }
|
---|
| 447 | /* OPT_L aka PRINT_FILES_WITHOUT_MATCHES: return early */
|
---|
| 448 | return 1; /* one match */
|
---|
| 449 | }
|
---|
[821] | 450 |
|
---|
| 451 | #if ENABLE_FEATURE_GREP_CONTEXT
|
---|
[1765] | 452 | /* Were we printing context and saw next (unwanted) match? */
|
---|
| 453 | if ((option_mask32 & OPT_m) && nmatches > max_matches)
|
---|
| 454 | break;
|
---|
| 455 | #endif
|
---|
[821] | 456 |
|
---|
[1765] | 457 | /* print the matched line */
|
---|
| 458 | if (PRINT_MATCH_COUNTS == 0) {
|
---|
| 459 | #if ENABLE_FEATURE_GREP_CONTEXT
|
---|
| 460 | int prevpos = (curpos == 0) ? lines_before - 1 : curpos - 1;
|
---|
[821] | 461 |
|
---|
[1765] | 462 | /* if we were told to print 'before' lines and there is at least
|
---|
| 463 | * one line in the circular buffer, print them */
|
---|
| 464 | if (lines_before && before_buf[prevpos] != NULL) {
|
---|
| 465 | int first_buf_entry_line_num = linenum - lines_before;
|
---|
[821] | 466 |
|
---|
[1765] | 467 | /* advance to the first entry in the circular buffer, and
|
---|
| 468 | * figure out the line number is of the first line in the
|
---|
| 469 | * buffer */
|
---|
| 470 | idx = curpos;
|
---|
| 471 | while (before_buf[idx] == NULL) {
|
---|
| 472 | idx = (idx + 1) % lines_before;
|
---|
| 473 | first_buf_entry_line_num++;
|
---|
[821] | 474 | }
|
---|
| 475 |
|
---|
[1765] | 476 | /* now print each line in the buffer, clearing them as we go */
|
---|
| 477 | while (before_buf[idx] != NULL) {
|
---|
[2725] | 478 | print_line(before_buf[idx], before_buf_size[idx], first_buf_entry_line_num, '-');
|
---|
[1765] | 479 | free(before_buf[idx]);
|
---|
| 480 | before_buf[idx] = NULL;
|
---|
| 481 | idx = (idx + 1) % lines_before;
|
---|
| 482 | first_buf_entry_line_num++;
|
---|
| 483 | }
|
---|
| 484 | }
|
---|
| 485 |
|
---|
| 486 | /* make a note that we need to print 'after' lines */
|
---|
| 487 | print_n_lines_after = lines_after;
|
---|
[821] | 488 | #endif
|
---|
[1765] | 489 | if (option_mask32 & OPT_o) {
|
---|
[2725] | 490 | if (FGREP_FLAG) {
|
---|
| 491 | /* -Fo just prints the pattern
|
---|
| 492 | * (unless -v: -Fov doesnt print anything at all) */
|
---|
| 493 | if (found)
|
---|
| 494 | print_line(gl->pattern, strlen(gl->pattern), linenum, ':');
|
---|
| 495 | } else while (1) {
|
---|
| 496 | unsigned start = gl->matched_range.rm_so;
|
---|
| 497 | unsigned end = gl->matched_range.rm_eo;
|
---|
| 498 | unsigned len = end - start;
|
---|
| 499 | char old = line[end];
|
---|
| 500 | line[end] = '\0';
|
---|
| 501 | /* Empty match is not printed: try "echo test | grep -o ''" */
|
---|
| 502 | if (len != 0)
|
---|
| 503 | print_line(line + start, len, linenum, ':');
|
---|
| 504 | if (old == '\0')
|
---|
| 505 | break;
|
---|
| 506 | line[end] = old;
|
---|
| 507 | if (len == 0)
|
---|
| 508 | end++;
|
---|
| 509 | #if !ENABLE_EXTRA_COMPAT
|
---|
| 510 | if (regexec(&gl->compiled_regex, line + end,
|
---|
| 511 | 1, &gl->matched_range, REG_NOTBOL) != 0)
|
---|
| 512 | break;
|
---|
| 513 | gl->matched_range.rm_so += end;
|
---|
| 514 | gl->matched_range.rm_eo += end;
|
---|
| 515 | #else
|
---|
| 516 | if (re_search(&gl->compiled_regex, line, line_len,
|
---|
| 517 | end, line_len - end,
|
---|
| 518 | &gl->matched_range) < 0)
|
---|
| 519 | break;
|
---|
| 520 | #endif
|
---|
| 521 | }
|
---|
[1765] | 522 | } else {
|
---|
[2725] | 523 | print_line(line, line_len, linenum, ':');
|
---|
[821] | 524 | }
|
---|
| 525 | }
|
---|
[1765] | 526 | }
|
---|
[821] | 527 | #if ENABLE_FEATURE_GREP_CONTEXT
|
---|
[1765] | 528 | else { /* no match */
|
---|
[821] | 529 | /* if we need to print some context lines after the last match, do so */
|
---|
[1765] | 530 | if (print_n_lines_after) {
|
---|
[2725] | 531 | print_line(line, strlen(line), linenum, '-');
|
---|
[821] | 532 | print_n_lines_after--;
|
---|
[1765] | 533 | } else if (lines_before) {
|
---|
| 534 | /* Add the line to the circular 'before' buffer */
|
---|
| 535 | free(before_buf[curpos]);
|
---|
| 536 | before_buf[curpos] = line;
|
---|
[2725] | 537 | IF_EXTRA_COMPAT(before_buf_size[curpos] = line_len;)
|
---|
[1765] | 538 | curpos = (curpos + 1) % lines_before;
|
---|
[2725] | 539 | /* avoid free(line) - we took the line */
|
---|
[1765] | 540 | line = NULL;
|
---|
[821] | 541 | }
|
---|
[1765] | 542 | }
|
---|
| 543 |
|
---|
[821] | 544 | #endif /* ENABLE_FEATURE_GREP_CONTEXT */
|
---|
[2725] | 545 | #if !ENABLE_EXTRA_COMPAT
|
---|
[821] | 546 | free(line);
|
---|
[2725] | 547 | #endif
|
---|
[1765] | 548 | /* Did we print all context after last requested match? */
|
---|
| 549 | if ((option_mask32 & OPT_m)
|
---|
[2725] | 550 | && !print_n_lines_after
|
---|
| 551 | && nmatches == max_matches
|
---|
| 552 | ) {
|
---|
[1765] | 553 | break;
|
---|
[2725] | 554 | }
|
---|
| 555 | } /* while (read line) */
|
---|
[821] | 556 |
|
---|
| 557 | /* special-case file post-processing for options where we don't print line
|
---|
| 558 | * matches, just filenames and possibly match counts */
|
---|
| 559 |
|
---|
| 560 | /* grep -c: print [filename:]count, even if count is zero */
|
---|
| 561 | if (PRINT_MATCH_COUNTS) {
|
---|
[1765] | 562 | if (print_filename)
|
---|
[821] | 563 | printf("%s:", cur_file);
|
---|
[1765] | 564 | printf("%d\n", nmatches);
|
---|
[821] | 565 | }
|
---|
| 566 |
|
---|
[1765] | 567 | /* grep -L: print just the filename */
|
---|
| 568 | if (PRINT_FILES_WITHOUT_MATCHES) {
|
---|
| 569 | /* nmatches is zero, no need to check it:
|
---|
| 570 | * we return 1 early if we detected a match
|
---|
| 571 | * and PRINT_FILES_WITHOUT_MATCHES is set */
|
---|
[821] | 572 | puts(cur_file);
|
---|
| 573 | }
|
---|
| 574 |
|
---|
| 575 | return nmatches;
|
---|
| 576 | }
|
---|
| 577 |
|
---|
| 578 | #if ENABLE_FEATURE_CLEAN_UP
|
---|
| 579 | #define new_grep_list_data(p, m) add_grep_list_data(p, m)
|
---|
[2725] | 580 | static char *add_grep_list_data(char *pattern, int flg_used_mem)
|
---|
[821] | 581 | #else
|
---|
| 582 | #define new_grep_list_data(p, m) add_grep_list_data(p)
|
---|
[2725] | 583 | static char *add_grep_list_data(char *pattern)
|
---|
[821] | 584 | #endif
|
---|
| 585 | {
|
---|
[2725] | 586 | grep_list_data_t *gl = xzalloc(sizeof(*gl));
|
---|
[821] | 587 | gl->pattern = pattern;
|
---|
| 588 | #if ENABLE_FEATURE_CLEAN_UP
|
---|
| 589 | gl->flg_mem_alocated_compiled = flg_used_mem;
|
---|
| 590 | #else
|
---|
[2725] | 591 | /*gl->flg_mem_alocated_compiled = 0;*/
|
---|
[821] | 592 | #endif
|
---|
| 593 | return (char *)gl;
|
---|
| 594 | }
|
---|
| 595 |
|
---|
| 596 | static void load_regexes_from_file(llist_t *fopt)
|
---|
| 597 | {
|
---|
[1765] | 598 | while (fopt) {
|
---|
[3232] | 599 | char *line;
|
---|
| 600 | FILE *fp;
|
---|
[821] | 601 | llist_t *cur = fopt;
|
---|
| 602 | char *ffile = cur->data;
|
---|
| 603 |
|
---|
| 604 | fopt = cur->link;
|
---|
| 605 | free(cur);
|
---|
[3232] | 606 | fp = xfopen_stdin(ffile);
|
---|
| 607 | while ((line = xmalloc_fgetline(fp)) != NULL) {
|
---|
[821] | 608 | llist_add_to(&pattern_head,
|
---|
[2725] | 609 | new_grep_list_data(line, ALLOCATED));
|
---|
[821] | 610 | }
|
---|
[3232] | 611 | fclose_if_not_stdin(fp);
|
---|
[821] | 612 | }
|
---|
| 613 | }
|
---|
| 614 |
|
---|
[2725] | 615 | static int FAST_FUNC file_action_grep(const char *filename,
|
---|
| 616 | struct stat *statbuf UNUSED_PARAM,
|
---|
| 617 | void* matched,
|
---|
| 618 | int depth UNUSED_PARAM)
|
---|
[1765] | 619 | {
|
---|
[2725] | 620 | FILE *file = fopen_for_read(filename);
|
---|
[1765] | 621 | if (file == NULL) {
|
---|
| 622 | if (!SUPPRESS_ERR_MSGS)
|
---|
[2725] | 623 | bb_simple_perror_msg(filename);
|
---|
[1765] | 624 | open_errors = 1;
|
---|
| 625 | return 0;
|
---|
| 626 | }
|
---|
| 627 | cur_file = filename;
|
---|
| 628 | *(int*)matched += grep_file(file);
|
---|
| 629 | fclose(file);
|
---|
| 630 | return 1;
|
---|
| 631 | }
|
---|
[821] | 632 |
|
---|
[1765] | 633 | static int grep_dir(const char *dir)
|
---|
| 634 | {
|
---|
| 635 | int matched = 0;
|
---|
| 636 | recursive_action(dir,
|
---|
| 637 | /* recurse=yes */ ACTION_RECURSE |
|
---|
| 638 | /* followLinks=no */
|
---|
| 639 | /* depthFirst=yes */ ACTION_DEPTHFIRST,
|
---|
| 640 | /* fileAction= */ file_action_grep,
|
---|
| 641 | /* dirAction= */ NULL,
|
---|
| 642 | /* userData= */ &matched,
|
---|
| 643 | /* depth= */ 0);
|
---|
| 644 | return matched;
|
---|
| 645 | }
|
---|
| 646 |
|
---|
[2725] | 647 | int grep_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
---|
| 648 | int grep_main(int argc UNUSED_PARAM, char **argv)
|
---|
[821] | 649 | {
|
---|
| 650 | FILE *file;
|
---|
| 651 | int matched;
|
---|
| 652 | llist_t *fopt = NULL;
|
---|
| 653 |
|
---|
| 654 | /* do normal option parsing */
|
---|
| 655 | #if ENABLE_FEATURE_GREP_CONTEXT
|
---|
[2725] | 656 | int Copt, opts;
|
---|
[821] | 657 |
|
---|
[2725] | 658 | /* -H unsets -h; -C unsets -A,-B; -e,-f are lists;
|
---|
| 659 | * -m,-A,-B,-C have numeric param */
|
---|
| 660 | opt_complementary = "H-h:C-AB:e::f::m+:A+:B+:C+";
|
---|
| 661 | opts = getopt32(argv,
|
---|
[1765] | 662 | OPTSTR_GREP,
|
---|
[2725] | 663 | &pattern_head, &fopt, &max_matches,
|
---|
| 664 | &lines_after, &lines_before, &Copt);
|
---|
[821] | 665 |
|
---|
[2725] | 666 | if (opts & OPT_C) {
|
---|
[1765] | 667 | /* -C unsets prev -A and -B, but following -A or -B
|
---|
[3232] | 668 | * may override it */
|
---|
[2725] | 669 | if (!(opts & OPT_A)) /* not overridden */
|
---|
| 670 | lines_after = Copt;
|
---|
| 671 | if (!(opts & OPT_B)) /* not overridden */
|
---|
| 672 | lines_before = Copt;
|
---|
[821] | 673 | }
|
---|
[1765] | 674 | /* sanity checks */
|
---|
[2725] | 675 | if (opts & (OPT_c|OPT_q|OPT_l|OPT_L)) {
|
---|
[1765] | 676 | option_mask32 &= ~OPT_n;
|
---|
[821] | 677 | lines_before = 0;
|
---|
| 678 | lines_after = 0;
|
---|
[2725] | 679 | } else if (lines_before > 0) {
|
---|
| 680 | if (lines_before > INT_MAX / sizeof(long long))
|
---|
| 681 | lines_before = INT_MAX / sizeof(long long);
|
---|
| 682 | /* overflow in (lines_before * sizeof(x)) is prevented (above) */
|
---|
| 683 | before_buf = xzalloc(lines_before * sizeof(before_buf[0]));
|
---|
| 684 | IF_EXTRA_COMPAT(before_buf_size = xzalloc(lines_before * sizeof(before_buf_size[0]));)
|
---|
| 685 | }
|
---|
[821] | 686 | #else
|
---|
| 687 | /* with auto sanity checks */
|
---|
[2725] | 688 | /* -H unsets -h; -c,-q or -l unset -n; -e,-f are lists; -m N */
|
---|
| 689 | opt_complementary = "H-h:c-n:q-n:l-n:e::f::m+";
|
---|
[1765] | 690 | getopt32(argv, OPTSTR_GREP,
|
---|
[2725] | 691 | &pattern_head, &fopt, &max_matches);
|
---|
[821] | 692 | #endif
|
---|
[1765] | 693 | invert_search = ((option_mask32 & OPT_v) != 0); /* 0 | 1 */
|
---|
[821] | 694 |
|
---|
[3232] | 695 | { /* convert char **argv to grep_list_data_t */
|
---|
[821] | 696 | llist_t *cur;
|
---|
[1765] | 697 | for (cur = pattern_head; cur; cur = cur->link)
|
---|
[821] | 698 | cur->data = new_grep_list_data(cur->data, 0);
|
---|
| 699 | }
|
---|
[3232] | 700 | if (option_mask32 & OPT_f) {
|
---|
[821] | 701 | load_regexes_from_file(fopt);
|
---|
[3232] | 702 | if (!pattern_head) { /* -f EMPTY_FILE? */
|
---|
| 703 | /* GNU grep treats it as "nothing matches" */
|
---|
| 704 | llist_add_to(&pattern_head, new_grep_list_data((char*) "", 0));
|
---|
| 705 | invert_search ^= 1;
|
---|
| 706 | }
|
---|
| 707 | }
|
---|
[821] | 708 |
|
---|
[1765] | 709 | if (ENABLE_FEATURE_GREP_FGREP_ALIAS && applet_name[0] == 'f')
|
---|
| 710 | option_mask32 |= OPT_F;
|
---|
[821] | 711 |
|
---|
[2725] | 712 | #if !ENABLE_EXTRA_COMPAT
|
---|
[1765] | 713 | if (!(option_mask32 & (OPT_o | OPT_w)))
|
---|
[821] | 714 | reflags = REG_NOSUB;
|
---|
[2725] | 715 | #endif
|
---|
[821] | 716 |
|
---|
[2725] | 717 | if (ENABLE_FEATURE_GREP_EGREP_ALIAS
|
---|
| 718 | && (applet_name[0] == 'e' || (option_mask32 & OPT_E))
|
---|
| 719 | ) {
|
---|
[1765] | 720 | reflags |= REG_EXTENDED;
|
---|
[2725] | 721 | }
|
---|
| 722 | #if ENABLE_EXTRA_COMPAT
|
---|
| 723 | else {
|
---|
| 724 | reflags = RE_SYNTAX_GREP;
|
---|
| 725 | }
|
---|
| 726 | #endif
|
---|
[1765] | 727 |
|
---|
[2725] | 728 | if (option_mask32 & OPT_i) {
|
---|
| 729 | #if !ENABLE_EXTRA_COMPAT
|
---|
[821] | 730 | reflags |= REG_ICASE;
|
---|
[2725] | 731 | #else
|
---|
| 732 | int i;
|
---|
| 733 | case_fold = xmalloc(256);
|
---|
| 734 | for (i = 0; i < 256; i++)
|
---|
| 735 | case_fold[i] = (unsigned char)i;
|
---|
| 736 | for (i = 'a'; i <= 'z'; i++)
|
---|
| 737 | case_fold[i] = (unsigned char)(i - ('a' - 'A'));
|
---|
| 738 | #endif
|
---|
| 739 | }
|
---|
[821] | 740 |
|
---|
| 741 | argv += optind;
|
---|
| 742 |
|
---|
[2725] | 743 | /* if we didn't get a pattern from -e and no command file was specified,
|
---|
| 744 | * first parameter should be the pattern. no pattern, no worky */
|
---|
[821] | 745 | if (pattern_head == NULL) {
|
---|
[1765] | 746 | char *pattern;
|
---|
[821] | 747 | if (*argv == NULL)
|
---|
| 748 | bb_show_usage();
|
---|
[1765] | 749 | pattern = new_grep_list_data(*argv++, 0);
|
---|
| 750 | llist_add_to(&pattern_head, pattern);
|
---|
[821] | 751 | }
|
---|
| 752 |
|
---|
[2725] | 753 | /* argv[0..(argc-1)] should be names of file to grep through. If
|
---|
[1765] | 754 | * there is more than one file to grep, we will print the filenames. */
|
---|
[2725] | 755 | if (argv[0] && argv[1])
|
---|
[1765] | 756 | print_filename = 1;
|
---|
| 757 | /* -H / -h of course override */
|
---|
| 758 | if (option_mask32 & OPT_H)
|
---|
| 759 | print_filename = 1;
|
---|
| 760 | if (option_mask32 & OPT_h)
|
---|
| 761 | print_filename = 0;
|
---|
[821] | 762 |
|
---|
| 763 | /* If no files were specified, or '-' was specified, take input from
|
---|
| 764 | * stdin. Otherwise, we grep through all the files specified. */
|
---|
| 765 | matched = 0;
|
---|
[2725] | 766 | do {
|
---|
| 767 | cur_file = *argv;
|
---|
[1765] | 768 | file = stdin;
|
---|
[2725] | 769 | if (!cur_file || LONE_DASH(cur_file)) {
|
---|
[821] | 770 | cur_file = "(standard input)";
|
---|
| 771 | } else {
|
---|
[1765] | 772 | if (option_mask32 & OPT_r) {
|
---|
| 773 | struct stat st;
|
---|
| 774 | if (stat(cur_file, &st) == 0 && S_ISDIR(st.st_mode)) {
|
---|
| 775 | if (!(option_mask32 & OPT_h))
|
---|
| 776 | print_filename = 1;
|
---|
| 777 | matched += grep_dir(cur_file);
|
---|
| 778 | goto grep_done;
|
---|
| 779 | }
|
---|
| 780 | }
|
---|
| 781 | /* else: fopen(dir) will succeed, but reading won't */
|
---|
[2725] | 782 | file = fopen_for_read(cur_file);
|
---|
[1765] | 783 | if (file == NULL) {
|
---|
| 784 | if (!SUPPRESS_ERR_MSGS)
|
---|
[2725] | 785 | bb_simple_perror_msg(cur_file);
|
---|
[1765] | 786 | open_errors = 1;
|
---|
| 787 | continue;
|
---|
[821] | 788 | }
|
---|
| 789 | }
|
---|
[1765] | 790 | matched += grep_file(file);
|
---|
| 791 | fclose_if_not_stdin(file);
|
---|
| 792 | grep_done: ;
|
---|
[2725] | 793 | } while (*argv && *++argv);
|
---|
[821] | 794 |
|
---|
| 795 | /* destroy all the elments in the pattern list */
|
---|
| 796 | if (ENABLE_FEATURE_CLEAN_UP) {
|
---|
| 797 | while (pattern_head) {
|
---|
| 798 | llist_t *pattern_head_ptr = pattern_head;
|
---|
[2725] | 799 | grep_list_data_t *gl = (grep_list_data_t *)pattern_head_ptr->data;
|
---|
[821] | 800 |
|
---|
| 801 | pattern_head = pattern_head->link;
|
---|
[2725] | 802 | if (gl->flg_mem_alocated_compiled & ALLOCATED)
|
---|
[821] | 803 | free(gl->pattern);
|
---|
[2725] | 804 | if (gl->flg_mem_alocated_compiled & COMPILED)
|
---|
| 805 | regfree(&gl->compiled_regex);
|
---|
[1765] | 806 | free(gl);
|
---|
[821] | 807 | free(pattern_head_ptr);
|
---|
| 808 | }
|
---|
| 809 | }
|
---|
| 810 | /* 0 = success, 1 = failed, 2 = error */
|
---|
[1765] | 811 | if (open_errors)
|
---|
[821] | 812 | return 2;
|
---|
[2725] | 813 | return !matched; /* invert return value: 0 = success, 1 = failed */
|
---|
[821] | 814 | }
|
---|