Changeset 2725 in MondoRescue for branches/2.2.9/mindi-busybox/findutils/grep.c

Timestamp:

Feb 25, 2011, 9:26:54 PM (13 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3

File:

• branches/2.2.9/mindi-busybox/findutils/grep.c (modified) (24 diffs)

branches/2.2.9/mindi-busybox/findutils/grep.c

@@ -6 +6 @@
  * Copyright (C) 1999,2000,2001 by Mark Whitley <markw@codepoet.org>
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
-/* BB_AUDIT SUSv3 defects - unsupported option -x.  */
+/* BB_AUDIT SUSv3 defects - unsupported option -x "match whole line only". */
 /* BB_AUDIT GNU defects - always acts as -a.  */
 /* http://www.opengroup.org/onlinepubs/007904975/utilities/grep.html */
@@ -15 +15 @@
  * correction "-e pattern1 -e pattern2" logic and more optimizations.
  * precompiled regex
- */
-/*
+ *
  * (C) 2006 Jac Goudsmit added -o option
  */
 
+//applet:IF_GREP(APPLET(grep, _BB_DIR_BIN, _BB_SUID_DROP))
+//applet:IF_FEATURE_GREP_EGREP_ALIAS(APPLET_ODDNAME(egrep, grep, _BB_DIR_BIN, _BB_SUID_DROP, egrep))
+//applet:IF_FEATURE_GREP_FGREP_ALIAS(APPLET_ODDNAME(fgrep, grep, _BB_DIR_BIN, _BB_SUID_DROP, fgrep))
+
+//kbuild:lib-$(CONFIG_GREP) += grep.o
+
+//config:config GREP
+//config:   bool "grep"
+//config:   default y
+//config:   help
+//config:     grep is used to search files for a specified pattern.
+//config:
+//config:config FEATURE_GREP_EGREP_ALIAS
+//config:   bool "Enable extended regular expressions (egrep & grep -E)"
+//config:   default y
+//config:   depends on GREP
+//config:   help
+//config:     Enabled support for extended regular expressions. Extended
+//config:     regular expressions allow for alternation (foo|bar), grouping,
+//config:     and various repetition operators.
+//config:
+//config:config FEATURE_GREP_FGREP_ALIAS
+//config:   bool "Alias fgrep to grep -F"
+//config:   default y
+//config:   depends on GREP
+//config:   help
+//config:     fgrep sees the search pattern as a normal string rather than
+//config:     regular expressions.
+//config:     grep -F always works, this just creates the fgrep alias.
+//config:
+//config:config FEATURE_GREP_CONTEXT
+//config:   bool "Enable before and after context flags (-A, -B and -C)"
+//config:   default y
+//config:   depends on GREP
+//config:   help
+//config:     Print the specified number of leading (-B) and/or trailing (-A)
+//config:     context surrounding our matching lines.
+//config:     Print the specified number of context lines (-C).
+
 #include "libbb.h"
 #include "xregex.h"
 
+
 /* options */
+//usage:#define grep_trivial_usage
+//usage:       "[-HhnlLoqvsriw"
+//usage:       "F"
+//usage:    IF_FEATURE_GREP_EGREP_ALIAS("E")
+//usage:    IF_EXTRA_COMPAT("z")
+//usage:       "] [-m N] "
+//usage:    IF_FEATURE_GREP_CONTEXT("[-A/B/C N] ")
+//usage:       "PATTERN/-e PATTERN.../-f FILE [FILE]..."
+//usage:#define grep_full_usage "\n\n"
+//usage:       "Search for PATTERN in FILEs (or stdin)\n"
+//usage:     "\nOptions:"
+//usage:     "\n    -H  Add 'filename:' prefix"
+//usage:     "\n    -h  Do not add 'filename:' prefix"
+//usage:     "\n    -n  Add 'line_no:' prefix"
+//usage:     "\n    -l  Show only names of files that match"
+//usage:     "\n    -L  Show only names of files that don't match"
+//usage:     "\n    -c  Show only count of matching lines"
+//usage:     "\n    -o  Show only the matching part of line"
+//usage:     "\n    -q  Quiet. Return 0 if PATTERN is found, 1 otherwise"
+//usage:     "\n    -v  Select non-matching lines"
+//usage:     "\n    -s  Suppress open and read errors"
+//usage:     "\n    -r  Recurse"
+//usage:     "\n    -i  Ignore case"
+//usage:     "\n    -w  Match whole words only"
+//usage:     "\n    -F  PATTERN is a literal (not regexp)"
+//usage:    IF_FEATURE_GREP_EGREP_ALIAS(
+//usage:     "\n    -E  PATTERN is an extended regexp"
+//usage:    )
+//usage:    IF_EXTRA_COMPAT(
+//usage:     "\n    -z  Input is NUL terminated"
+//usage:    )
+//usage:     "\n    -m N    Match up to N times per file"
+//usage:    IF_FEATURE_GREP_CONTEXT(
+//usage:     "\n    -A N    Print N lines of trailing context"
+//usage:     "\n    -B N    Print N lines of leading context"
+//usage:     "\n    -C N    Same as '-A N -B N'"
+//usage:    )
+//usage:     "\n    -e PTRN Pattern to match"
+//usage:     "\n    -f FILE Read pattern from file"
+//usage:
+//usage:#define grep_example_usage
+//usage:       "$ grep root /etc/passwd\n"
+//usage:       "root:x:0:0:root:/root:/bin/bash\n"
+//usage:       "$ grep ^[rR]oo. /etc/passwd\n"
+//usage:       "root:x:0:0:root:/root:/bin/bash\n"
+//usage:
+//usage:#define egrep_trivial_usage NOUSAGE_STR
+//usage:#define egrep_full_usage ""
+//usage:#define fgrep_trivial_usage NOUSAGE_STR
+//usage:#define fgrep_full_usage ""
+
 #define OPTSTR_GREP \
-    "lnqvscFiHhe:f:Lorm:" \
-    USE_FEATURE_GREP_CONTEXT("A:B:C:") \
-    USE_FEATURE_GREP_EGREP_ALIAS("E") \
-    USE_DESKTOP("w") \
+    "lnqvscFiHhe:f:Lorm:w" \
+    IF_FEATURE_GREP_CONTEXT("A:B:C:") \
+    IF_FEATURE_GREP_EGREP_ALIAS("E") \
+    IF_EXTRA_COMPAT("z") \
     "aI"
 /* ignored: -a "assume all files to be text" */
 /* ignored: -I "assume binary files have no matches" */
-
 enum {
     OPTBIT_l, /* list matched file names only */
     OPTBIT_n, /* print line# */
-    OPTBIT_q, /* quiet - exit(0) of first match */
+    OPTBIT_q, /* quiet - exit(EXIT_SUCCESS) of first match */
     OPTBIT_v, /* invert the match, to select non-matching lines */
     OPTBIT_s, /* suppress errors about file open errors */
@@ -50 +139 @@
     OPTBIT_r, /* recurse dirs */
     OPTBIT_m, /* -m MAX_MATCHES */
-    USE_FEATURE_GREP_CONTEXT(    OPTBIT_A ,) /* -A NUM: after-match context */
-    USE_FEATURE_GREP_CONTEXT(    OPTBIT_B ,) /* -B NUM: before-match context */
-    USE_FEATURE_GREP_CONTEXT(    OPTBIT_C ,) /* -C NUM: -A and -B combined */
-    USE_FEATURE_GREP_EGREP_ALIAS(OPTBIT_E ,) /* extended regexp */
-    USE_DESKTOP(                 OPTBIT_w ,) /* whole word match */
+    OPTBIT_w, /* -w whole word match */
+    IF_FEATURE_GREP_CONTEXT(    OPTBIT_A ,) /* -A NUM: after-match context */
+    IF_FEATURE_GREP_CONTEXT(    OPTBIT_B ,) /* -B NUM: before-match context */
+    IF_FEATURE_GREP_CONTEXT(    OPTBIT_C ,) /* -C NUM: -A and -B combined */
+    IF_FEATURE_GREP_EGREP_ALIAS(OPTBIT_E ,) /* extended regexp */
+    IF_EXTRA_COMPAT(            OPTBIT_z ,) /* input is NUL terminated */
     OPT_l = 1 << OPTBIT_l,
     OPT_n = 1 << OPTBIT_n,
@@ -71 +161 @@
     OPT_r = 1 << OPTBIT_r,
     OPT_m = 1 << OPTBIT_m,
-    OPT_A = USE_FEATURE_GREP_CONTEXT(    (1 << OPTBIT_A)) + 0,
-    OPT_B = USE_FEATURE_GREP_CONTEXT(    (1 << OPTBIT_B)) + 0,
-    OPT_C = USE_FEATURE_GREP_CONTEXT(    (1 << OPTBIT_C)) + 0,
-    OPT_E = USE_FEATURE_GREP_EGREP_ALIAS((1 << OPTBIT_E)) + 0,
-    OPT_w = USE_DESKTOP(                 (1 << OPTBIT_w)) + 0,
+    OPT_w = 1 << OPTBIT_w,
+    OPT_A = IF_FEATURE_GREP_CONTEXT(    (1 << OPTBIT_A)) + 0,
+    OPT_B = IF_FEATURE_GREP_CONTEXT(    (1 << OPTBIT_B)) + 0,
+    OPT_C = IF_FEATURE_GREP_CONTEXT(    (1 << OPTBIT_C)) + 0,
+    OPT_E = IF_FEATURE_GREP_EGREP_ALIAS((1 << OPTBIT_E)) + 0,
+    OPT_z = IF_EXTRA_COMPAT(            (1 << OPTBIT_z)) + 0,
 };
 
@@ -85 +176 @@
 #define FGREP_FLAG                  (option_mask32 & OPT_F)
 #define PRINT_FILES_WITHOUT_MATCHES (option_mask32 & OPT_L)
-
-typedef unsigned char byte_t;
-
-static int max_matches;
-static int reflags;
-static byte_t invert_search;
-static byte_t print_filename;
-static byte_t open_errors;
-
+#define NUL_DELIMITED               (option_mask32 & OPT_z)
+
+struct globals {
+    int max_matches;
+#if !ENABLE_EXTRA_COMPAT
+    int reflags;
+#else
+    RE_TRANSLATE_TYPE case_fold; /* RE_TRANSLATE_TYPE is [[un]signed] char* */
+#endif
+    smalluint invert_search;
+    smalluint print_filename;
+    smalluint open_errors;
 #if ENABLE_FEATURE_GREP_CONTEXT
-static byte_t did_print_line;
-static int lines_before;
-static int lines_after;
-static char **before_buf;
-static int last_line_printed;
-#endif /* ENABLE_FEATURE_GREP_CONTEXT */
-/* globals used internally */
-static llist_t *pattern_head;   /* growable list of patterns to match */
-static const char *cur_file;    /* the current file we are reading */
+    smalluint did_print_line;
+    int lines_before;
+    int lines_after;
+    char **before_buf;
+    IF_EXTRA_COMPAT(size_t *before_buf_size;)
+    int last_line_printed;
+#endif
+    /* globals used internally */
+    llist_t *pattern_head;   /* growable list of patterns to match */
+    const char *cur_file;    /* the current file we are reading */
+} FIX_ALIASING;
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define INIT_G() do { \
+    struct G_sizecheck { \
+        char G_sizecheck[sizeof(G) > COMMON_BUFSIZE ? -1 : 1]; \
+    }; \
+} while (0)
+#define max_matches       (G.max_matches         )
+#if !ENABLE_EXTRA_COMPAT
+# define reflags          (G.reflags             )
+#else
+# define case_fold        (G.case_fold           )
+/* http://www.delorie.com/gnu/docs/regex/regex_46.html */
+# define reflags           re_syntax_options
+# undef REG_NOSUB
+# undef REG_EXTENDED
+# undef REG_ICASE
+# define REG_NOSUB    bug:is:here /* should not be used */
+/* Just RE_SYNTAX_EGREP is not enough, need to enable {n[,[m]]} too */
+# define REG_EXTENDED (RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES)
+# define REG_ICASE    bug:is:here /* should not be used */
+#endif
+#define invert_search     (G.invert_search       )
+#define print_filename    (G.print_filename      )
+#define open_errors       (G.open_errors         )
+#define did_print_line    (G.did_print_line      )
+#define lines_before      (G.lines_before        )
+#define lines_after       (G.lines_after         )
+#define before_buf        (G.before_buf          )
+#define before_buf_size   (G.before_buf_size     )
+#define last_line_printed (G.last_line_printed   )
+#define pattern_head      (G.pattern_head        )
+#define cur_file          (G.cur_file            )
+
 
 typedef struct grep_list_data_t {
     char *pattern;
-    regex_t preg;
-#define PATTERN_MEM_A 1
+/* for GNU regex, matched_range must be persistent across grep_file() calls */
+#if !ENABLE_EXTRA_COMPAT
+    regex_t compiled_regex;
+    regmatch_t matched_range;
+#else
+    struct re_pattern_buffer compiled_regex;
+    struct re_registers matched_range;
+#endif
+#define ALLOCATED 1
 #define COMPILED 2
     int flg_mem_alocated_compiled;
 } grep_list_data_t;
 
-static void print_line(const char *line, int linenum, char decoration)
+#if !ENABLE_EXTRA_COMPAT
+#define print_line(line, line_len, linenum, decoration) \
+    print_line(line, linenum, decoration)
+#endif
+static void print_line(const char *line, size_t line_len, int linenum, char decoration)
 {
 #if ENABLE_FEATURE_GREP_CONTEXT
@@ -121 +261 @@
         return;
     /* possibly print the little '--' separator */
-    if ((lines_before || lines_after) && did_print_line &&
-            last_line_printed != linenum - 1) {
+    if ((lines_before || lines_after) && did_print_line
+     && last_line_printed != linenum - 1
+    ) {
         puts("--");
     }
@@ -134 +275 @@
         printf("%i%c", linenum, decoration);
     /* Emulate weird GNU grep behavior with -ov */
-    if ((option_mask32 & (OPT_v|OPT_o)) != (OPT_v|OPT_o))
+    if ((option_mask32 & (OPT_v|OPT_o)) != (OPT_v|OPT_o)) {
+#if !ENABLE_EXTRA_COMPAT
         puts(line);
+#else
+        fwrite(line, 1, line_len, stdout);
+        putchar(NUL_DELIMITED ? '\0' : '\n');
+#endif
+    }
 }
+
+#if ENABLE_EXTRA_COMPAT
+/* Unlike getline, this one removes trailing '\n' */
+static ssize_t FAST_FUNC bb_getline(char **line_ptr, size_t *line_alloc_len, FILE *file)
+{
+    ssize_t res_sz;
+    char *line;
+    int delim = (NUL_DELIMITED ? '\0' : '\n');
+
+    res_sz = getdelim(line_ptr, line_alloc_len, delim, file);
+    line = *line_ptr;
+
+    if (res_sz > 0) {
+        if (line[res_sz - 1] == delim)
+            line[--res_sz] = '\0';
+    } else {
+        free(line); /* uclibc allocates a buffer even on EOF. WTF? */
+    }
+    return res_sz;
+}
+#endif
 
 static int grep_file(FILE *file)
 {
-    char *line;
-    byte_t ret;
+    smalluint found;
     int linenum = 0;
     int nmatches = 0;
-    regmatch_t regmatch;
+#if !ENABLE_EXTRA_COMPAT
+    char *line;
+#else
+    char *line = NULL;
+    ssize_t line_len;
+    size_t line_alloc_len;
+# define rm_so start[0]
+# define rm_eo end[0]
+#endif
 #if ENABLE_FEATURE_GREP_CONTEXT
     int print_n_lines_after = 0;
@@ -151 +326 @@
 #else
     enum { print_n_lines_after = 0 };
-#endif /* ENABLE_FEATURE_GREP_CONTEXT */
-
-    while ((line = xmalloc_getline(file)) != NULL) {
+#endif
+
+    while (
+#if !ENABLE_EXTRA_COMPAT
+        (line = xmalloc_fgetline(file)) != NULL
+#else
+        (line_len = bb_getline(&line, &line_alloc_len, file)) >= 0
+#endif
+    ) {
         llist_t *pattern_ptr = pattern_head;
-        grep_list_data_t * gl;
+        grep_list_data_t *gl = gl; /* for gcc */
 
         linenum++;
-        ret = 0;
+        found = 0;
         while (pattern_ptr) {
             gl = (grep_list_data_t *)pattern_ptr->data;
             if (FGREP_FLAG) {
-                ret = strstr(line, gl->pattern) != NULL;
+                found |= (((option_mask32 & OPT_i)
+                    ? strcasestr(line, gl->pattern)
+                    : strstr(line, gl->pattern)
+                    ) != NULL);
             } else {
-                /*
-                 * test for a postitive-assertion match (regexec returns success (0)
-                 * and the user did not specify invert search), or a negative-assertion
-                 * match (regexec returns failure (REG_NOMATCH) and the user specified
-                 * invert search)
-                 */
                 if (!(gl->flg_mem_alocated_compiled & COMPILED)) {
                     gl->flg_mem_alocated_compiled |= COMPILED;
-                    xregcomp(&(gl->preg), gl->pattern, reflags);
+#if !ENABLE_EXTRA_COMPAT
+                    xregcomp(&gl->compiled_regex, gl->pattern, reflags);
+#else
+                    memset(&gl->compiled_regex, 0, sizeof(gl->compiled_regex));
+                    gl->compiled_regex.translate = case_fold; /* for -i */
+                    if (re_compile_pattern(gl->pattern, strlen(gl->pattern), &gl->compiled_regex))
+                        bb_error_msg_and_die("bad regex '%s'", gl->pattern);
+#endif
                 }
-                regmatch.rm_so = 0;
-                regmatch.rm_eo = 0;
-                if (regexec(&(gl->preg), line, 1, &regmatch, 0) == 0) {
+#if !ENABLE_EXTRA_COMPAT
+                gl->matched_range.rm_so = 0;
+                gl->matched_range.rm_eo = 0;
+#endif
+                if (
+#if !ENABLE_EXTRA_COMPAT
+                    regexec(&gl->compiled_regex, line, 1, &gl->matched_range, 0) == 0
+#else
+                    re_search(&gl->compiled_regex, line, line_len,
+                            /*start:*/ 0, /*range:*/ line_len,
+                            &gl->matched_range) >= 0
+#endif
+                ) {
                     if (!(option_mask32 & OPT_w))
-                        ret = 1;
+                        found = 1;
                     else {
                         char c = ' ';
-                        if (regmatch.rm_so)
-                            c = line[regmatch.rm_so - 1];
+                        if (gl->matched_range.rm_so)
+                            c = line[gl->matched_range.rm_so - 1];
                         if (!isalnum(c) && c != '_') {
-                            c = line[regmatch.rm_eo];
+                            c = line[gl->matched_range.rm_eo];
                             if (!c || (!isalnum(c) && c != '_'))
-                                ret = 1;
+                                found = 1;
                         }
                     }
                 }
             }
+            /* If it's non-inverted search, we can stop
+             * at first match */
+            if (found && !invert_search)
+                goto do_found;
             pattern_ptr = pattern_ptr->link;
         } /* while (pattern_ptr) */
 
-        if (ret ^ invert_search) {
+        if (found ^ invert_search) {
+ do_found:
             /* keep track of matches */
             nmatches++;
@@ -206 +406 @@
                      * if any match is found,
                      * even if errors were detected" */
-                    exit(0);
+                    exit(EXIT_SUCCESS);
                 }
                 /* if we're just printing filenames, we stop after the first match */
                 if (PRINT_FILES_WITH_MATCHES) {
                     puts(cur_file);
-                    /* fall thru to "return 1" */
+                    /* fall through to "return 1" */
                 }
                 /* OPT_L aka PRINT_FILES_WITHOUT_MATCHES: return early */
@@ -244 +444 @@
                     /* now print each line in the buffer, clearing them as we go */
                     while (before_buf[idx] != NULL) {
-                        print_line(before_buf[idx], first_buf_entry_line_num, '-');
+                        print_line(before_buf[idx], before_buf_size[idx], first_buf_entry_line_num, '-');
                         free(before_buf[idx]);
                         before_buf[idx] = NULL;
@@ -256 +456 @@
 #endif
                 if (option_mask32 & OPT_o) {
-                    line[regmatch.rm_eo] = '\0';
-                    print_line(line + regmatch.rm_so, linenum, ':');
+                    if (FGREP_FLAG) {
+                        /* -Fo just prints the pattern
+                         * (unless -v: -Fov doesnt print anything at all) */
+                        if (found)
+                            print_line(gl->pattern, strlen(gl->pattern), linenum, ':');
+                    } else while (1) {
+                        unsigned start = gl->matched_range.rm_so;
+                        unsigned end = gl->matched_range.rm_eo;
+                        unsigned len = end - start;
+                        char old = line[end];
+                        line[end] = '\0';
+                        /* Empty match is not printed: try "echo test | grep -o ''" */
+                        if (len != 0)
+                            print_line(line + start, len, linenum, ':');
+                        if (old == '\0')
+                            break;
+                        line[end] = old;
+                        if (len == 0)
+                            end++;
+#if !ENABLE_EXTRA_COMPAT
+                        if (regexec(&gl->compiled_regex, line + end,
+                                1, &gl->matched_range, REG_NOTBOL) != 0)
+                            break;
+                        gl->matched_range.rm_so += end;
+                        gl->matched_range.rm_eo += end;
+#else
+                        if (re_search(&gl->compiled_regex, line, line_len,
+                                end, line_len - end,
+                                &gl->matched_range) < 0)
+                            break;
+#endif
+                    }
                 } else {
-                    print_line(line, linenum, ':');
+                    print_line(line, line_len, linenum, ':');
                 }
             }
@@ -267 +497 @@
             /* if we need to print some context lines after the last match, do so */
             if (print_n_lines_after) {
-                print_line(line, linenum, '-');
+                print_line(line, strlen(line), linenum, '-');
                 print_n_lines_after--;
             } else if (lines_before) {
@@ -273 +503 @@
                 free(before_buf[curpos]);
                 before_buf[curpos] = line;
+                IF_EXTRA_COMPAT(before_buf_size[curpos] = line_len;)
                 curpos = (curpos + 1) % lines_before;
-                /* avoid free(line) - we took line */
+                /* avoid free(line) - we took the line */
                 line = NULL;
             }
@@ -280 +511 @@
 
 #endif /* ENABLE_FEATURE_GREP_CONTEXT */
+#if !ENABLE_EXTRA_COMPAT
         free(line);
-
+#endif
         /* Did we print all context after last requested match? */
         if ((option_mask32 & OPT_m)
-         && !print_n_lines_after && nmatches == max_matches)
+         && !print_n_lines_after
+         && nmatches == max_matches
+        ) {
             break;
-    }
+        }
+    } /* while (read line) */
 
     /* special-case file post-processing for options where we don't print line
@@ -311 +546 @@
 #if ENABLE_FEATURE_CLEAN_UP
 #define new_grep_list_data(p, m) add_grep_list_data(p, m)
-static char * add_grep_list_data(char *pattern, int flg_used_mem)
+static char *add_grep_list_data(char *pattern, int flg_used_mem)
 #else
 #define new_grep_list_data(p, m) add_grep_list_data(p)
-static char * add_grep_list_data(char *pattern)
+static char *add_grep_list_data(char *pattern)
 #endif
 {
-    grep_list_data_t *gl = xmalloc(sizeof(grep_list_data_t));
+    grep_list_data_t *gl = xzalloc(sizeof(*gl));
     gl->pattern = pattern;
 #if ENABLE_FEATURE_CLEAN_UP
     gl->flg_mem_alocated_compiled = flg_used_mem;
 #else
-    gl->flg_mem_alocated_compiled = 0;
+    /*gl->flg_mem_alocated_compiled = 0;*/
 #endif
     return (char *)gl;
@@ -338 +573 @@
         fopt = cur->link;
         free(cur);
-        f = xfopen(ffile, "r");
-        while ((line = xmalloc_getline(f)) != NULL) {
+        f = xfopen_stdin(ffile);
+        while ((line = xmalloc_fgetline(f)) != NULL) {
             llist_add_to(&pattern_head,
-                new_grep_list_data(line, PATTERN_MEM_A));
+                new_grep_list_data(line, ALLOCATED));
         }
     }
 }
 
-static int file_action_grep(const char *filename, struct stat *statbuf, void* matched, int depth)
+static int FAST_FUNC file_action_grep(const char *filename,
+            struct stat *statbuf UNUSED_PARAM,
+            void* matched,
+            int depth UNUSED_PARAM)
 {
-    FILE *file = fopen(filename, "r");
+    FILE *file = fopen_for_read(filename);
     if (file == NULL) {
         if (!SUPPRESS_ERR_MSGS)
-            bb_perror_msg("%s", cur_file);
+            bb_simple_perror_msg(filename);
         open_errors = 1;
         return 0;
@@ -375 +613 @@
 }
 
-int grep_main(int argc, char **argv);
-int grep_main(int argc, char **argv)
+int grep_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int grep_main(int argc UNUSED_PARAM, char **argv)
 {
     FILE *file;
     int matched;
-    char *mopt;
     llist_t *fopt = NULL;
 
     /* do normal option parsing */
 #if ENABLE_FEATURE_GREP_CONTEXT
-    char *slines_after;
-    char *slines_before;
-    char *Copt;
-
-    opt_complementary = "H-h:e::f::C-AB";
-    getopt32(argv,
+    int Copt, opts;
+
+    /* -H unsets -h; -C unsets -A,-B; -e,-f are lists;
+     * -m,-A,-B,-C have numeric param */
+    opt_complementary = "H-h:C-AB:e::f::m+:A+:B+:C+";
+    opts = getopt32(argv,
         OPTSTR_GREP,
-        &pattern_head, &fopt, &mopt,
-        &slines_after, &slines_before, &Copt);
-
-    if (option_mask32 & OPT_C) {
+        &pattern_head, &fopt, &max_matches,
+        &lines_after, &lines_before, &Copt);
+
+    if (opts & OPT_C) {
         /* -C unsets prev -A and -B, but following -A or -B
            may override it */
-        if (!(option_mask32 & OPT_A)) /* not overridden */
-            slines_after = Copt;
-        if (!(option_mask32 & OPT_B)) /* not overridden */
-            slines_before = Copt;
-        option_mask32 |= OPT_A|OPT_B; /* for parser */
-    }
-    if (option_mask32 & OPT_A) {
-        lines_after = xatoi_u(slines_after);
-    }
-    if (option_mask32 & OPT_B) {
-        lines_before = xatoi_u(slines_before);
+        if (!(opts & OPT_A)) /* not overridden */
+            lines_after = Copt;
+        if (!(opts & OPT_B)) /* not overridden */
+            lines_before = Copt;
     }
     /* sanity checks */
-    if (option_mask32 & (OPT_c|OPT_q|OPT_l|OPT_L)) {
+    if (opts & (OPT_c|OPT_q|OPT_l|OPT_L)) {
         option_mask32 &= ~OPT_n;
         lines_before = 0;
         lines_after = 0;
-    } else if (lines_before > 0)
-        before_buf = xzalloc(lines_before * sizeof(char *));
+    } else if (lines_before > 0) {
+        if (lines_before > INT_MAX / sizeof(long long))
+            lines_before = INT_MAX / sizeof(long long);
+        /* overflow in (lines_before * sizeof(x)) is prevented (above) */
+        before_buf = xzalloc(lines_before * sizeof(before_buf[0]));
+        IF_EXTRA_COMPAT(before_buf_size = xzalloc(lines_before * sizeof(before_buf_size[0]));)
+    }
 #else
     /* with auto sanity checks */
-    opt_complementary = "H-h:e::f::c-n:q-n:l-n";
+    /* -H unsets -h; -c,-q or -l unset -n; -e,-f are lists; -m N */
+    opt_complementary = "H-h:c-n:q-n:l-n:e::f::m+";
     getopt32(argv, OPTSTR_GREP,
-        &pattern_head, &fopt, &mopt);
-#endif
-    if (option_mask32 & OPT_m) {
-        max_matches = xatoi_u(mopt);
-    }
+        &pattern_head, &fopt, &max_matches);
+#endif
     invert_search = ((option_mask32 & OPT_v) != 0); /* 0 | 1 */
 
@@ -441 +674 @@
         option_mask32 |= OPT_F;
 
+#if !ENABLE_EXTRA_COMPAT
     if (!(option_mask32 & (OPT_o | OPT_w)))
         reflags = REG_NOSUB;
-
-    if (ENABLE_FEATURE_GREP_EGREP_ALIAS &&
-            (applet_name[0] == 'e' || (option_mask32 & OPT_E)))
+#endif
+
+    if (ENABLE_FEATURE_GREP_EGREP_ALIAS
+     && (applet_name[0] == 'e' || (option_mask32 & OPT_E))
+    ) {
         reflags |= REG_EXTENDED;
-
-    if (option_mask32 & OPT_i)
+    }
+#if ENABLE_EXTRA_COMPAT
+    else {
+        reflags = RE_SYNTAX_GREP;
+    }
+#endif
+
+    if (option_mask32 & OPT_i) {
+#if !ENABLE_EXTRA_COMPAT
         reflags |= REG_ICASE;
+#else
+        int i;
+        case_fold = xmalloc(256);
+        for (i = 0; i < 256; i++)
+            case_fold[i] = (unsigned char)i;
+        for (i = 'a'; i <= 'z'; i++)
+            case_fold[i] = (unsigned char)(i - ('a' - 'A'));
+#endif
+    }
 
     argv += optind;
-    argc -= optind;
-
-    /* if we didn't get a pattern from a -e and no command file was specified,
-     * argv[optind] should be the pattern. no pattern, no worky */
+
+    /* if we didn't get a pattern from -e and no command file was specified,
+     * first parameter should be the pattern. no pattern, no worky */
     if (pattern_head == NULL) {
         char *pattern;
@@ -462 +713 @@
         pattern = new_grep_list_data(*argv++, 0);
         llist_add_to(&pattern_head, pattern);
-        argc--;
-    }
-
-    /* argv[(optind)..(argc-1)] should be names of file to grep through. If
+    }
+
+    /* argv[0..(argc-1)] should be names of file to grep through. If
      * there is more than one file to grep, we will print the filenames. */
-    if (argc > 1)
+    if (argv[0] && argv[1])
         print_filename = 1;
     /* -H / -h of course override */
@@ -477 +727 @@
     /* If no files were specified, or '-' was specified, take input from
      * stdin. Otherwise, we grep through all the files specified. */
-    if (argc == 0)
-        argc++;
     matched = 0;
-    while (argc--) {
-        cur_file = *argv++;
+    do {
+        cur_file = *argv;
         file = stdin;
-        if (!cur_file || (*cur_file == '-' && !cur_file[1])) {
+        if (!cur_file || LONE_DASH(cur_file)) {
             cur_file = "(standard input)";
         } else {
@@ -496 +744 @@
             }
             /* else: fopen(dir) will succeed, but reading won't */
-            file = fopen(cur_file, "r");
+            file = fopen_for_read(cur_file);
             if (file == NULL) {
                 if (!SUPPRESS_ERR_MSGS)
-                    bb_perror_msg("%s", cur_file);
+                    bb_simple_perror_msg(cur_file);
                 open_errors = 1;
                 continue;
@@ -507 +755 @@
         fclose_if_not_stdin(file);
  grep_done: ;
-    }
+    } while (*argv && *++argv);
 
     /* destroy all the elments in the pattern list */
@@ -513 +761 @@
         while (pattern_head) {
             llist_t *pattern_head_ptr = pattern_head;
-            grep_list_data_t *gl =
-                (grep_list_data_t *)pattern_head_ptr->data;
+            grep_list_data_t *gl = (grep_list_data_t *)pattern_head_ptr->data;
 
             pattern_head = pattern_head->link;
-            if ((gl->flg_mem_alocated_compiled & PATTERN_MEM_A))
+            if (gl->flg_mem_alocated_compiled & ALLOCATED)
                 free(gl->pattern);
-            if ((gl->flg_mem_alocated_compiled & COMPILED))
-                regfree(&(gl->preg));
+            if (gl->flg_mem_alocated_compiled & COMPILED)
+                regfree(&gl->compiled_regex);
             free(gl);
             free(pattern_head_ptr);
@@ -528 +775 @@
     if (open_errors)
         return 2;
-    return !matched; /* invert return value 0 = success, 1 = failed */
+    return !matched; /* invert return value: 0 = success, 1 = failed */
 }