/[pcre]/code/trunk/pcregrep.c

Diff of /code/trunk/pcregrep.c

Parent Directory | Revision Log | View Patch Patch

-revision 137 by ph10,
Thu Mar 29 13:56:00 2007 UTC
+revision 1004 by ph10,
Fri Aug 17 08:26:17 2012 UTC
 Line 6
  its pattern matching. On a Unix or Win32 system it can recurse into
  directories.
-            Copyright (c) 1997-2007 University of Cambridge
+            Copyright (c) 1997-2012 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 38 
 POSSIBILITY OF SUCH DAMAGE.
  */
  #ifdef HAVE_CONFIG_H
- #  include <config.h>
+ #include "config.h"
  #endif
  #include <ctype.h>
 Line 50 
 POSSIBILITY OF SUCH DAMAGE.
  #include <sys/types.h>
  #include <sys/stat.h>
  #ifdef HAVE_UNISTD_H
- #  include <unistd.h>
+ #include <unistd.h>
+ #endif
+ #ifdef SUPPORT_LIBZ
+ #include <zlib.h>
+ #endif
+ #ifdef SUPPORT_LIBBZ2
+ #include <bzlib.h>
  #endif
- #include <pcre.h>
+ #include "pcre.h"
  #define FALSE 0
  #define TRUE 1
  typedef int BOOL;
- #define MAX_PATTERN_COUNT 100
+ #define OFFSET_SIZE 99
  #if BUFSIZ > 8192
- #define MBUFTHIRD BUFSIZ
+ #define MAXPATLEN BUFSIZ
  #else
- #define MBUFTHIRD 8192
+ #define MAXPATLEN 8192
  #endif
+ #define PATBUFSIZE (MAXPATLEN + 10)   /* Allows for prefix+suffix */
  /* Values for the "filenames" variable, which specifies options for file name
  output. The order is important; it is assumed that a file name is wanted for
  all values greater than FN_DEFAULT. */
- enum { FN_NONE, FN_DEFAULT, FN_ONLY, FN_NOMATCH_ONLY, FN_FORCE };
+ enum { FN_NONE, FN_DEFAULT, FN_MATCH_ONLY, FN_NOMATCH_ONLY, FN_FORCE };
+ /* File reading styles */
+ enum { FR_PLAIN, FR_LIBZ, FR_LIBBZ2 };
  /* Actions for the -d and -D options */
-Line 88 
 enum { DEE_READ, DEE_SKIP };
+Line 103 
 enum { DEE_READ, DEE_SKIP };
  /* Line ending types */
- enum { EL_LF, EL_CR, EL_CRLF, EL_ANY };
+ enum { EL_LF, EL_CR, EL_CRLF, EL_ANY, EL_ANYCRLF };
+ /* Binary file options */
+ enum { BIN_BINARY, BIN_NOMATCH, BIN_TEXT };
+ /* In newer versions of gcc, with FORTIFY_SOURCE set (the default in some
+ environments), a warning is issued if the value of fwrite() is ignored.
+ Unfortunately, casting to (void) does not suppress the warning. To get round
+ this, we use a macro that compiles a fudge. Oddly, this does not also seem to
+ apply to fprintf(). */
+ #define FWRITE(a,b,c,d) if (fwrite(a,b,c,d)) {}
-Line 113 
 static char *colour_string = (char *)"1;
+Line 140 
 static char *colour_string = (char *)"1;
  static char *colour_option = NULL;
  static char *dee_option = NULL;
  static char *DEE_option = NULL;
+ static char *locale = NULL;
+ static char *main_buffer = NULL;
  static char *newline = NULL;
- static char *pattern_filename = NULL;
  static char *stdin_name = (char *)"(standard input)";
- static char *locale = NULL;
  static const unsigned char *pcretables = NULL;
- static int  pattern_count = 0;
- static pcre **pattern_list = NULL;
- static pcre_extra **hints_list = NULL;
- static char *include_pattern = NULL;
- static char *exclude_pattern = NULL;
- static pcre *include_compiled = NULL;
- static pcre *exclude_compiled = NULL;
  static int after_context = 0;
  static int before_context = 0;
+ static int binary_files = BIN_BINARY;
  static int both_context = 0;
+ static int bufthird = PCREGREP_BUFSIZE;
+ static int bufsize = 3*PCREGREP_BUFSIZE;
+ #if defined HAVE_WINDOWS_H && HAVE_WINDOWS_H
+ static int dee_action = dee_SKIP;
+ #else
  static int dee_action = dee_READ;
+ #endif
  static int DEE_action = DEE_READ;
  static int error_count = 0;
  static int filenames = FN_DEFAULT;
+ static int only_matching = -1;
+ static int pcre_options = 0;
  static int process_options = 0;
+ #ifdef SUPPORT_PCREGREP_JIT
+ static int study_options = PCRE_STUDY_JIT_COMPILE;
+ #else
+ static int study_options = 0;
+ #endif
+ static unsigned long int match_limit = 0;
+ static unsigned long int match_limit_recursion = 0;
  static BOOL count_only = FALSE;
  static BOOL do_colour = FALSE;
+ static BOOL file_offsets = FALSE;
  static BOOL hyphenpending = FALSE;
  static BOOL invert = FALSE;
+ static BOOL line_buffered = FALSE;
+ static BOOL line_offsets = FALSE;
  static BOOL multiline = FALSE;
  static BOOL number = FALSE;
- static BOOL only_matching = FALSE;
+ static BOOL omit_zero_count = FALSE;
+ static BOOL resource_error = FALSE;
  static BOOL quiet = FALSE;
  static BOOL silent = FALSE;
  static BOOL utf8 = FALSE;
+ /* Structure for list of file names (for -f and --{in,ex}clude-from) */
+ typedef struct fnstr {
+   struct fnstr *next;
+   char *name;
+ } fnstr;
+ static fnstr *exclude_from = NULL;
+ static fnstr *exclude_from_last = NULL;
+ static fnstr *include_from = NULL;
+ static fnstr *include_from_last = NULL;
+ static fnstr *file_lists = NULL;
+ static fnstr *file_lists_last = NULL;
+ static fnstr *pattern_files = NULL;
+ static fnstr *pattern_files_last = NULL;
+ /* Structure for holding the two variables that describe a file name chain. */
+ typedef struct fndatastr {
+   fnstr **anchor;
+   fnstr **lastptr;
+ } fndatastr;
+ static fndatastr exclude_from_data = { &exclude_from, &exclude_from_last };
+ static fndatastr include_from_data = { &include_from, &include_from_last };
+ static fndatastr file_lists_data = { &file_lists, &file_lists_last };
+ static fndatastr pattern_files_data = { &pattern_files, &pattern_files_last };
+ /* Structure for pattern and its compiled form; used for matching patterns and
+ also for include/exclude patterns. */
+ typedef struct patstr {
+   struct patstr *next;
+   char *string;
+   pcre *compiled;
+   pcre_extra *hint;
+ } patstr;
+ static patstr *patterns = NULL;
+ static patstr *patterns_last = NULL;
+ static patstr *include_patterns = NULL;
+ static patstr *include_patterns_last = NULL;
+ static patstr *exclude_patterns = NULL;
+ static patstr *exclude_patterns_last = NULL;
+ static patstr *include_dir_patterns = NULL;
+ static patstr *include_dir_patterns_last = NULL;
+ static patstr *exclude_dir_patterns = NULL;
+ static patstr *exclude_dir_patterns_last = NULL;
+ /* Structure holding the two variables that describe a pattern chain. A pointer
+ to such structures is used for each appropriate option. */
+ typedef struct patdatastr {
+   patstr **anchor;
+   patstr **lastptr;
+ } patdatastr;
+ static patdatastr match_patdata = { &patterns, &patterns_last };
+ static patdatastr include_patdata = { &include_patterns, &include_patterns_last };
+ static patdatastr exclude_patdata = { &exclude_patterns, &exclude_patterns_last };
+ static patdatastr include_dir_patdata = { &include_dir_patterns, &include_dir_patterns_last };
+ static patdatastr exclude_dir_patdata = { &exclude_dir_patterns, &exclude_dir_patterns_last };
+ static patstr **incexlist[4] = { &include_patterns, &exclude_patterns,
+                                  &include_dir_patterns, &exclude_dir_patterns };
+ static const char *incexname[4] = { "--include", "--exclude",
+                                     "--include-dir", "--exclude-dir" };
  /* Structure for options and list of them */
- enum { OP_NODATA, OP_STRING, OP_OP_STRING, OP_NUMBER, OP_OP_NUMBER,
+ enum { OP_NODATA, OP_STRING, OP_OP_STRING, OP_NUMBER, OP_LONGNUMBER,
-        OP_PATLIST };
+        OP_OP_NUMBER, OP_PATLIST, OP_FILELIST, OP_BINFILES };
  typedef struct option_item {
    int type;
-Line 166 
 typedef struct option_item {
+Line 277 
 typedef struct option_item {
  /* Options without a single-letter equivalent get a negative value. This can be
  used to identify them. */
- #define N_COLOUR    (-1)
+ #define N_COLOUR       (-1)
- #define N_EXCLUDE   (-2)
+ #define N_EXCLUDE      (-2)
- #define N_HELP      (-3)
+ #define N_EXCLUDE_DIR  (-3)
- #define N_INCLUDE   (-4)
+ #define N_HELP         (-4)
- #define N_LABEL     (-5)
+ #define N_INCLUDE      (-5)
- #define N_LOCALE    (-6)
+ #define N_INCLUDE_DIR  (-6)
- #define N_NULL      (-7)
+ #define N_LABEL        (-7)
+ #define N_LOCALE       (-8)
+ #define N_NULL         (-9)
+ #define N_LOFFSETS     (-10)
+ #define N_FOFFSETS     (-11)
+ #define N_LBUFFER      (-12)
+ #define N_M_LIMIT      (-13)
+ #define N_M_LIMIT_REC  (-14)
+ #define N_BUFSIZE      (-15)
+ #define N_NOJIT        (-16)
+ #define N_FILE_LIST    (-17)
+ #define N_BINARY_FILES (-18)
+ #define N_EXCLUDE_FROM (-19)
+ #define N_INCLUDE_FROM (-20)
  static option_item optionlist[] = {
-   { OP_NODATA,    N_NULL,   NULL,              "",              "  terminate options" },
+   { OP_NODATA,     N_NULL,   NULL,              "",              "terminate options" },
-   { OP_NODATA,    N_HELP,   NULL,              "help",          "display this help and exit" },
+   { OP_NODATA,     N_HELP,   NULL,              "help",          "display this help and exit" },
-   { OP_NUMBER,    'A',      &after_context,    "after-context=number", "set number of following context lines" },
+   { OP_NUMBER,     'A',      &after_context,    "after-context=number", "set number of following context lines" },
-   { OP_NUMBER,    'B',      &before_context,   "before-context=number", "set number of prior context lines" },
+   { OP_NODATA,     'a',      NULL,              "text",          "treat binary files as text" },
-   { OP_OP_STRING, N_COLOUR, &colour_option,    "color=option",  "matched text color option" },
+   { OP_NUMBER,     'B',      &before_context,   "before-context=number", "set number of prior context lines" },
-   { OP_NUMBER,    'C',      &both_context,     "context=number", "set number of context lines, before & after" },
+   { OP_BINFILES,   N_BINARY_FILES, NULL,        "binary-files=word", "set treatment of binary files" },
-   { OP_NODATA,    'c',      NULL,              "count",         "print only a count of matching lines per FILE" },
+   { OP_NUMBER,     N_BUFSIZE,&bufthird,         "buffer-size=number", "set processing buffer size parameter" },
-   { OP_OP_STRING, N_COLOUR, &colour_option,    "colour=option", "matched text colour option" },
+   { OP_OP_STRING,  N_COLOUR, &colour_option,    "color=option",  "matched text color option" },
-   { OP_STRING,    'D',      &DEE_option,       "devices=action","how to handle devices, FIFOs, and sockets" },
+   { OP_OP_STRING,  N_COLOUR, &colour_option,    "colour=option", "matched text colour option" },
-   { OP_STRING,    'd',      &dee_option,       "directories=action", "how to handle directories" },
+   { OP_NUMBER,     'C',      &both_context,     "context=number", "set number of context lines, before & after" },
-   { OP_PATLIST,   'e',      NULL,              "regex(p)",      "specify pattern (may be used more than once)" },
+   { OP_NODATA,     'c',      NULL,              "count",         "print only a count of matching lines per FILE" },
-   { OP_NODATA,    'F',      NULL,              "fixed_strings", "patterns are sets of newline-separated strings" },
+   { OP_STRING,     'D',      &DEE_option,       "devices=action","how to handle devices, FIFOs, and sockets" },
-   { OP_STRING,    'f',      &pattern_filename, "file=path",     "read patterns from file" },
+   { OP_STRING,     'd',      &dee_option,       "directories=action", "how to handle directories" },
-   { OP_NODATA,    'H',      NULL,              "with-filename", "force the prefixing filename on output" },
+   { OP_PATLIST,    'e',      &match_patdata,    "regex(p)=pattern", "specify pattern (may be used more than once)" },
-   { OP_NODATA,    'h',      NULL,              "no-filename",   "suppress the prefixing filename on output" },
+   { OP_NODATA,     'F',      NULL,              "fixed-strings", "patterns are sets of newline-separated strings" },
-   { OP_NODATA,    'i',      NULL,              "ignore-case",   "ignore case distinctions" },
+   { OP_FILELIST,   'f',      &pattern_files_data, "file=path",   "read patterns from file" },
-   { OP_NODATA,    'l',      NULL,              "files-with-matches", "print only FILE names containing matches" },
+   { OP_FILELIST,   N_FILE_LIST, &file_lists_data, "file-list=path","read files to search from file" },
-   { OP_NODATA,    'L',      NULL,              "files-without-match","print only FILE names not containing matches" },
+   { OP_NODATA,     N_FOFFSETS, NULL,            "file-offsets",  "output file offsets, not text" },
-   { OP_STRING,    N_LABEL,  &stdin_name,       "label=name",    "set name for standard input" },
+   { OP_NODATA,     'H',      NULL,              "with-filename", "force the prefixing filename on output" },
-   { OP_STRING,    N_LOCALE, &locale,           "locale=locale", "use the named locale" },
+   { OP_NODATA,     'h',      NULL,              "no-filename",   "suppress the prefixing filename on output" },
-   { OP_NODATA,    'M',      NULL,              "multiline",     "run in multiline mode" },
+   { OP_NODATA,     'I',      NULL,              "",              "treat binary files as not matching (ignore)" },
-   { OP_STRING,    'N',      &newline,          "newline=type",  "specify newline type (CR, LR, CRLF)" },
+   { OP_NODATA,     'i',      NULL,              "ignore-case",   "ignore case distinctions" },
-   { OP_NODATA,    'n',      NULL,              "line-number",   "print line number with output lines" },
+ #ifdef SUPPORT_PCREGREP_JIT
-   { OP_NODATA,    'o',      NULL,              "only-matching", "show only the part of the line that matched" },
+   { OP_NODATA,     N_NOJIT,  NULL,              "no-jit",        "do not use just-in-time compiler optimization" },
-   { OP_NODATA,    'q',      NULL,              "quiet",         "suppress output, just set return code" },
+ #else
-   { OP_NODATA,    'r',      NULL,              "recursive",     "recursively scan sub-directories" },
+   { OP_NODATA,     N_NOJIT,  NULL,              "no-jit",        "ignored: this pcregrep does not support JIT" },
-   { OP_STRING,    N_EXCLUDE,&exclude_pattern,  "exclude=pattern","exclude matching files when recursing" },
+ #endif
-   { OP_STRING,    N_INCLUDE,&include_pattern,  "include=pattern","include matching files when recursing" },
+   { OP_NODATA,     'l',      NULL,              "files-with-matches", "print only FILE names containing matches" },
+   { OP_NODATA,     'L',      NULL,              "files-without-match","print only FILE names not containing matches" },
+   { OP_STRING,     N_LABEL,  &stdin_name,       "label=name",    "set name for standard input" },
+   { OP_NODATA,     N_LBUFFER, NULL,             "line-buffered", "use line buffering" },
+   { OP_NODATA,     N_LOFFSETS, NULL,            "line-offsets",  "output line numbers and offsets, not text" },
+   { OP_STRING,     N_LOCALE, &locale,           "locale=locale", "use the named locale" },
+   { OP_LONGNUMBER, N_M_LIMIT, &match_limit,     "match-limit=number", "set PCRE match limit option" },
+   { OP_LONGNUMBER, N_M_LIMIT_REC, &match_limit_recursion, "recursion-limit=number", "set PCRE match recursion limit option" },
+   { OP_NODATA,     'M',      NULL,              "multiline",     "run in multiline mode" },
+   { OP_STRING,     'N',      &newline,          "newline=type",  "set newline type (CR, LF, CRLF, ANYCRLF or ANY)" },
+   { OP_NODATA,     'n',      NULL,              "line-number",   "print line number with output lines" },
+   { OP_OP_NUMBER,  'o',      &only_matching,    "only-matching=n", "show only the part of the line that matched" },
+   { OP_NODATA,     'q',      NULL,              "quiet",         "suppress output, just set return code" },
+   { OP_NODATA,     'r',      NULL,              "recursive",     "recursively scan sub-directories" },
+   { OP_PATLIST,    N_EXCLUDE,&exclude_patdata,  "exclude=pattern","exclude matching files when recursing" },
+   { OP_PATLIST,    N_INCLUDE,&include_patdata,  "include=pattern","include matching files when recursing" },
+   { OP_PATLIST,    N_EXCLUDE_DIR,&exclude_dir_patdata, "exclude-dir=pattern","exclude matching directories when recursing" },
+   { OP_PATLIST,    N_INCLUDE_DIR,&include_dir_patdata, "include-dir=pattern","include matching directories when recursing" },
+   { OP_FILELIST,   N_EXCLUDE_FROM,&exclude_from_data, "exclude-from=path", "read exclude list from file" },
+   { OP_FILELIST,   N_INCLUDE_FROM,&include_from_data, "include-from=path", "read include list from file" },
+   /* These two were accidentally implemented with underscores instead of
+   hyphens in the option names. As this was not discovered for several releases,
+   the incorrect versions are left in the table for compatibility. However, the
+   --help function misses out any option that has an underscore in its name. */
+   { OP_PATLIST,   N_EXCLUDE_DIR,&exclude_dir_patdata, "exclude_dir=pattern","exclude matching directories when recursing" },
+   { OP_PATLIST,   N_INCLUDE_DIR,&include_dir_patdata, "include_dir=pattern","include matching directories when recursing" },
  #ifdef JFRIEDL_DEBUG
    { OP_OP_NUMBER, 'S',      &S_arg,            "jeffS",         "replace matched (sub)string with X" },
  #endif
-Line 218 
 static option_item optionlist[] = {
+Line 370 
 static option_item optionlist[] = {
  /* Tables for prefixing and suffixing patterns, according to the -w, -x, and -F
  options. These set the 1, 2, and 4 bits in process_options, respectively. Note
  that the combination of -w and -x has the same effect as -x on its own, so we
- can treat them as the same. */
+ can treat them as the same. Note that the MAXPATLEN macro assumes the longest
+ prefix+suffix is 10 characters; if anything longer is added, it must be
+ adjusted. */
  static const char *prefix[] = {
    "", "\\b", "^(?:", "^(?:", "\\Q", "\\b\\Q", "^(?:\\Q", "^(?:\\Q" };
-Line 226 
 static const char *prefix[] = {
+Line 380 
 static const char *prefix[] = {
  static const char *suffix[] = {
    "", "\\b", ")$",   ")$",   "\\E", "\\E\\b", "\\E)$",   "\\E)$" };
- /* UTF-8 tables - used only when the newline setting is "all". */
+ /* UTF-8 tables - used only when the newline setting is "any". */
  const int utf8_table3[] = { 0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};
-Line 239 
 const char utf8_table4[] = {
+Line 393 
 const char utf8_table4[] = {
  /*************************************************
+ *          Add item to chain of patterns         *
+ *************************************************/
+ /* Used to add an item onto a chain, or just return an unconnected item if the
+ "after" argument is NULL.
+ Arguments:
+   s          pattern string to add
+   after      if not NULL points to item to insert after
+ Returns:     new pattern block, or NULL after malloc failure
+ */
+ static patstr *
+ add_pattern(char *s, patstr *after)
+ {
+ patstr *p = (patstr *)malloc(sizeof(patstr));
+ if (p == NULL)
+   {
+   fprintf(stderr, "pcregrep: malloc failed\n");
+   return NULL;
+   }
+ if (strlen(s) > MAXPATLEN)
+   {
+   fprintf(stderr, "pcregrep: pattern is too long (limit is %d bytes)\n",
+     MAXPATLEN);
+   return NULL;
+   }
+ p->next = NULL;
+ p->string = s;
+ p->compiled = NULL;
+ p->hint = NULL;
+ if (after != NULL)
+   {
+   p->next = after->next;
+   after->next = p;
+   }
+ return p;
+ }
+ /*************************************************
+ *           Free chain of patterns               *
+ *************************************************/
+ /* Used for several chains of patterns.
+ Argument: pointer to start of chain
+ Returns:  nothing
+ */
+ static void
+ free_pattern_chain(patstr *pc)
+ {
+ while (pc != NULL)
+   {
+   patstr *p = pc;
+   pc = p->next;
+   if (p->hint != NULL) pcre_free_study(p->hint);
+   if (p->compiled != NULL) pcre_free(p->compiled);
+   free(p);
+   }
+ }
+ /*************************************************
+ *           Free chain of file names             *
+ *************************************************/
+ /*
+ Argument: pointer to start of chain
+ Returns:  nothing
+ */
+ static void
+ free_file_chain(fnstr *fn)
+ {
+ while (fn != NULL)
+   {
+   fnstr *f = fn;
+   fn = f->next;
+   free(f);
+   }
+ }
+ /*************************************************
+ *         Exit from the program                  *
+ *************************************************/
+ /* If there has been a resource error, give a suitable message.
+ Argument:  the return code
+ Returns:   does not return
+ */
+ static void
+ pcregrep_exit(int rc)
+ {
+ if (resource_error)
+   {
+   fprintf(stderr, "pcregrep: Error %d, %d or %d means that a resource limit "
+     "was exceeded.\n", PCRE_ERROR_MATCHLIMIT, PCRE_ERROR_RECURSIONLIMIT,
+     PCRE_ERROR_JIT_STACKLIMIT);
+   fprintf(stderr, "pcregrep: Check your regex for nested unlimited loops.\n");
+   }
+ exit(rc);
+ }
+ /*************************************************
  *            OS-specific functions               *
  *************************************************/
-Line 254 
 although at present the only ones are fo
+Line 521 
 although at present the only ones are fo
  #include <dirent.h>
  typedef DIR directory_type;
+ #define FILESEP '/'
  static int
  isdirectory(char *filename)
-Line 261 
 isdirectory(char *filename)
+Line 529 
 isdirectory(char *filename)
  struct stat statbuf;
  if (stat(filename, &statbuf) < 0)
    return 0;        /* In the expectation that opening as a file will fail */
- return ((statbuf.st_mode & S_IFMT) == S_IFDIR)? '/' : 0;
+ return (statbuf.st_mode & S_IFMT) == S_IFDIR;
  }
  static directory_type *
-Line 280 
 for (;;)
+Line 548 
 for (;;)
    if (strcmp(dent->d_name, ".") != 0 && strcmp(dent->d_name, "..") != 0)
      return dent->d_name;
    }
- return NULL;   /* Keep compiler happy; never executed */
+ /* Control never reaches here */
  }
  static void
-Line 302 
 return (statbuf.st_mode & S_IFMT) == S_I
+Line 570 
 return (statbuf.st_mode & S_IFMT) == S_I
  }
- /************* Test stdout for being a terminal in Unix **********/
+ /************* Test for a terminal in Unix **********/
  static BOOL
  is_stdout_tty(void)
-Line 310 
 is_stdout_tty(void)
+Line 578 
 is_stdout_tty(void)
  return isatty(fileno(stdout));
  }
+ static BOOL
+ is_file_tty(FILE *f)
+ {
+ return isatty(fileno(f));
+ }
  /************* Directory scanning in Win32 ***********/
  /* I (Philip Hazel) have no means of testing this code. It was contributed by
  Lionel Fourquaux. David Burgess added a patch to define INVALID_FILE_ATTRIBUTES
- when it did not exist. */
+ when it did not exist. David Byron added a patch that moved the #include of
+ <windows.h> to before the INVALID_FILE_ATTRIBUTES definition rather than after.
+ The double test below stops gcc 4.4.4 grumbling that HAVE_WINDOWS_H is
+ undefined when it is indeed undefined. */
- #elif HAVE_WINDOWS_H
+ #elif defined HAVE_WINDOWS_H && HAVE_WINDOWS_H
  #ifndef STRICT
  # define STRICT
-Line 326 
 when it did not exist. */
+Line 602 
 when it did not exist. */
  #ifndef WIN32_LEAN_AND_MEAN
  # define WIN32_LEAN_AND_MEAN
  #endif
+ #include <windows.h>
  #ifndef INVALID_FILE_ATTRIBUTES
  #define INVALID_FILE_ATTRIBUTES 0xFFFFFFFF
  #endif
- #include <windows.h>
  typedef struct directory_type
  {
  HANDLE handle;
-Line 339 
 BOOL first;
+Line 616 
 BOOL first;
  WIN32_FIND_DATA data;
  } directory_type;
+ #define FILESEP '/'
  int
  isdirectory(char *filename)
  {
  DWORD attr = GetFileAttributes(filename);
  if (attr == INVALID_FILE_ATTRIBUTES)
    return 0;
- return ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) ? '/' : 0;
+ return (attr & FILE_ATTRIBUTE_DIRECTORY) != 0;
  }
  directory_type *
-Line 356 
 char *pattern;
+Line 635 
 char *pattern;
  directory_type *dir;
  DWORD err;
  len = strlen(filename);
- pattern = (char *) malloc(len + 3);
+ pattern = (char *)malloc(len + 3);
- dir = (directory_type *) malloc(sizeof(*dir));
+ dir = (directory_type *)malloc(sizeof(*dir));
  if ((pattern == NULL) || (dir == NULL))
    {
    fprintf(stderr, "pcregrep: malloc failed\n");
-   exit(2);
+   pcregrep_exit(2);
    }
  memcpy(pattern, filename, len);
  memcpy(&(pattern[len]), "\\*", 3);
-Line 416 
 regular if they are not directories. */
+Line 695 
 regular if they are not directories. */
  int isregfile(char *filename)
  {
- return !isdirectory(filename)
+ return !isdirectory(filename);
  }
- /************* Test stdout for being a terminal in Win32 **********/
+ /************* Test for a terminal in Win32 **********/
  /* I don't know how to do this; assume never */
  static BOOL
  is_stdout_tty(void)
  {
- FALSE;
+ return FALSE;
+ }
+ static BOOL
+ is_file_tty(FILE *f)
+ {
+ return FALSE;
  }
-Line 437 
 FALSE;
+Line 722 
 FALSE;
  #else
+ #define FILESEP 0;
  typedef void directory_type;
  int isdirectory(char *filename) { return 0; }
-Line 452 
 void closedirectory(directory_type *dir)
+Line 738 
 void closedirectory(directory_type *dir)
  int isregfile(char *filename) { return 1; }
- /************* Test stdout for being a terminal when we can't do it **********/
+ /************* Test for a terminal when we can't do it **********/
  static BOOL
  is_stdout_tty(void)
-Line 460 
 is_stdout_tty(void)
+Line 746 
 is_stdout_tty(void)
  return FALSE;
  }
+ static BOOL
+ is_file_tty(FILE *f)
+ {
+ return FALSE;
+ }
  #endif
-Line 488 
 return sys_errlist[n];
+Line 779 
 return sys_errlist[n];
  /*************************************************
+ *            Test exclude/includes               *
+ *************************************************/
+ /* If any exclude pattern matches, the path is excluded. Otherwise, unless
+ there are no includes, the path must match an include pattern.
+ Arguments:
+   path      the path to be matched
+   ip        the chain of include patterns
+   ep        the chain of exclude patterns
+ Returns:    TRUE if the path is not excluded
+ */
+ static BOOL
+ test_incexc(char *path, patstr *ip, patstr *ep)
+ {
+ int plen = strlen(path);
+ for (; ep != NULL; ep = ep->next)
+   {
+   if (pcre_exec(ep->compiled, NULL, path, plen, 0, 0, NULL, 0) >= 0)
+     return FALSE;
+   }
+ if (ip == NULL) return TRUE;
+ for (; ip != NULL; ip = ip->next)
+   {
+   if (pcre_exec(ip->compiled, NULL, path, plen, 0, 0, NULL, 0) >= 0)
+     return TRUE;
+   }
+ return FALSE;
+ }
+ /*************************************************
+ *            Read one line of input              *
+ *************************************************/
+ /* Normally, input is read using fread() into a large buffer, so many lines may
+ be read at once. However, doing this for tty input means that no output appears
+ until a lot of input has been typed. Instead, tty input is handled line by
+ line. We cannot use fgets() for this, because it does not stop at a binary
+ zero, and therefore there is no way of telling how many characters it has read,
+ because there may be binary zeros embedded in the data.
+ Arguments:
+   buffer     the buffer to read into
+   length     the maximum number of characters to read
+   f          the file
+ Returns:     the number of characters read, zero at end of file
+ */
+ static unsigned int
+ read_one_line(char *buffer, int length, FILE *f)
+ {
+ int c;
+ int yield = 0;
+ while ((c = fgetc(f)) != EOF)
+   {
+   buffer[yield++] = c;
+   if (c == '\n' || yield >= length) break;
+   }
+ return yield;
+ }
+ /*************************************************
  *             Find end of line                   *
  *************************************************/
-Line 499 
 Arguments:
+Line 863 
 Arguments:
    endptr    end of available data
    lenptr    where to put the length of the eol sequence
- Returns:    pointer to the last byte of the line
+ Returns:    pointer after the last byte of the line,
+             including the newline byte(s)
  */
  static char *
-Line 545 
 switch(endlinetype)
+Line 910 
 switch(endlinetype)
      }
    break;
+   case EL_ANYCRLF:
+   while (p < endptr)
+     {
+     int extra = 0;
+     register int c = *((unsigned char *)p);
+     if (utf8 && c >= 0xc0)
+       {
+       int gcii, gcss;
+       extra = utf8_table4[c & 0x3f];  /* Number of additional bytes */
+       gcss = 6*extra;
+       c = (c & utf8_table3[extra]) << gcss;
+       for (gcii = 1; gcii <= extra; gcii++)
+         {
+         gcss -= 6;
+         c |= (p[gcii] & 0x3f) << gcss;
+         }
+       }
+     p += 1 + extra;
+     switch (c)
+       {
+       case 0x0a:    /* LF */
+       *lenptr = 1;
+       return p;
+       case 0x0d:    /* CR */
+       if (p < endptr && *p == 0x0a)
+         {
+         *lenptr = 2;
+         p++;
+         }
+       else *lenptr = 1;
+       return p;
+       default:
+       break;
+       }
+     }   /* End of loop for ANYCRLF case */
+   *lenptr = 0;  /* Must have hit the end */
+   return endptr;
    case EL_ANY:
    while (p < endptr)
      {
-Line 643 
 switch(endlinetype)
+Line 1052 
 switch(endlinetype)
    return p;   /* But control should never get here */
    case EL_ANY:
+   case EL_ANYCRLF:
    if (*(--p) == '\n' && p > startptr && p[-1] == '\r') p--;
    if (utf8) while ((*p & 0xc0) == 0x80) p--;
-Line 671 
 switch(endlinetype)
+Line 1081 
 switch(endlinetype)
        }
      else c = *((unsigned char *)pp);
-     switch (c)
+     if (endlinetype == EL_ANYCRLF) switch (c)
+       {
+       case 0x0a:    /* LF */
+       case 0x0d:    /* CR */
+       return p;
+       default:
+       break;
+       }
+     else switch (c)
        {
        case 0x0a:    /* LF */
        case 0x0b:    /* VT */
-Line 714 
 Arguments:
+Line 1134 
 Arguments:
  Returns:            nothing
  */
- static void do_after_lines(int lastmatchnumber, char *lastmatchrestart,
+ static void
-   char *endptr, char *printname)
+ do_after_lines(int lastmatchnumber, char *lastmatchrestart, char *endptr,
+   char *printname)
  {
  if (after_context > 0 && lastmatchnumber > 0)
    {
-Line 727 
 if (after_context > 0 && lastmatchnumber
+Line 1148 
 if (after_context > 0 && lastmatchnumber
      if (printname != NULL) fprintf(stdout, "%s-", printname);
      if (number) fprintf(stdout, "%d-", lastmatchnumber++);
      pp = end_of_line(pp, endptr, &ellength);
-     fwrite(lastmatchrestart, 1, pp - lastmatchrestart, stdout);
+     FWRITE(lastmatchrestart, 1, pp - lastmatchrestart, stdout);
      lastmatchrestart = pp;
      }
    hyphenpending = TRUE;
-Line 737 
 if (after_context > 0 && lastmatchnumber
+Line 1158 
 if (after_context > 0 && lastmatchnumber
  /*************************************************
+ *   Apply patterns to subject till one matches   *
+ *************************************************/
+ /* This function is called to run through all patterns, looking for a match. It
+ is used multiple times for the same subject when colouring is enabled, in order
+ to find all possible matches.
+ Arguments:
+   matchptr     the start of the subject
+   length       the length of the subject to match
+   startoffset  where to start matching
+   offsets      the offets vector to fill in
+   mrc          address of where to put the result of pcre_exec()
+ Returns:      TRUE if there was a match
+               FALSE if there was no match
+               invert if there was a non-fatal error
+ */
+ static BOOL
+ match_patterns(char *matchptr, size_t length, int startoffset, int *offsets,
+   int *mrc)
+ {
+ int i;
+ size_t slen = length;
+ patstr *p = patterns;
+ const char *msg = "this text:\n\n";
+ if (slen > 200)
+   {
+   slen = 200;
+   msg = "text that starts:\n\n";
+   }
+ for (i = 1; p != NULL; p = p->next, i++)
+   {
+   *mrc = pcre_exec(p->compiled, p->hint, matchptr, (int)length,
+     startoffset, PCRE_NOTEMPTY, offsets, OFFSET_SIZE);
+   if (*mrc >= 0) return TRUE;
+   if (*mrc == PCRE_ERROR_NOMATCH) continue;
+   fprintf(stderr, "pcregrep: pcre_exec() gave error %d while matching ", *mrc);
+   if (patterns->next != NULL) fprintf(stderr, "pattern number %d to ", i);
+   fprintf(stderr, "%s", msg);
+   FWRITE(matchptr, 1, slen, stderr);   /* In case binary zero included */
+   fprintf(stderr, "\n\n");
+   if (*mrc == PCRE_ERROR_MATCHLIMIT || *mrc == PCRE_ERROR_RECURSIONLIMIT ||
+       *mrc == PCRE_ERROR_JIT_STACKLIMIT)
+     resource_error = TRUE;
+   if (error_count++ > 20)
+     {
+     fprintf(stderr, "pcregrep: Too many errors - abandoned.\n");
+     pcregrep_exit(2);
+     }
+   return invert;    /* No more matching; don't show the line again */
+   }
+ return FALSE;  /* No match, no errors */
+ }
+ /*************************************************
  *            Grep an individual file             *
  *************************************************/
  /* This is called from grep_or_recurse() below. It uses a buffer that is three
- times the value of MBUFTHIRD. The matching point is never allowed to stray into
+ times the value of bufthird. The matching point is never allowed to stray into
  the top third of the buffer, thus keeping more of the file available for
  context printing or for multiline scanning. For large files, the pointer will
  be in the middle third most of the time, so the bottom third is available for
  "before" context printing.
  Arguments:
-   in           the fopened FILE stream
+   handle       the fopened FILE stream for a normal file
+                the gzFile pointer when reading is via libz
+                the BZFILE pointer when reading is via libbz2
+   frtype       FR_PLAIN, FR_LIBZ, or FR_LIBBZ2
+   filename     the file name or NULL (for errors)
    printname    the file name if it is to be printed for each match
                 or NULL if the file name is not to be printed
                 it cannot be NULL if filenames[_nomatch]_only is set
  Returns:       0 if there was at least one match
 otherwise (no matches)
+if an overlong line is encountered
+if there is a read error on a .bz2 file
  */
  static int
- pcregrep(FILE *in, char *printname)
+ pcregrep(void *handle, int frtype, char *filename, char *printname)
  {
  int rc = 1;
  int linenumber = 1;
  int lastmatchnumber = 0;
  int count = 0;
- int offsets[99];
+ int filepos = 0;
+ int offsets[OFFSET_SIZE];
  char *lastmatchrestart = NULL;
- char buffer[3*MBUFTHIRD];
+ char *ptr = main_buffer;
- char *ptr = buffer;
  char *endptr;
  size_t bufflength;
+ BOOL binary = FALSE;
  BOOL endhyphenpending = FALSE;
+ BOOL input_line_buffered = line_buffered;
+ FILE *in = NULL;                    /* Ensure initialized */
+ #ifdef SUPPORT_LIBZ
+ gzFile ingz = NULL;
+ #endif
- /* Do the first read into the start of the buffer and set up the pointer to
+ #ifdef SUPPORT_LIBBZ2
- end of what we have. */
+ BZFILE *inbz2 = NULL;
+ #endif
+ /* Do the first read into the start of the buffer and set up the pointer to end
+ of what we have. In the case of libz, a non-zipped .gz file will be read as a
+ plain file. However, if a .bz2 file isn't actually bzipped, the first read will
+ fail. */
+ #ifdef SUPPORT_LIBZ
+ if (frtype == FR_LIBZ)
+   {
+   ingz = (gzFile)handle;
+   bufflength = gzread (ingz, main_buffer, bufsize);
+   }
+ else
+ #endif
+ #ifdef SUPPORT_LIBBZ2
+ if (frtype == FR_LIBBZ2)
+   {
+   inbz2 = (BZFILE *)handle;
+   bufflength = BZ2_bzread(inbz2, main_buffer, bufsize);
+   if ((int)bufflength < 0) return 2;   /* Gotcha: bufflength is size_t; */
+   }                                    /* without the cast it is unsigned. */
+ else
+ #endif
+   {
+   in = (FILE *)handle;
+   if (is_file_tty(in)) input_line_buffered = TRUE;
+   bufflength = input_line_buffered?
+     read_one_line(main_buffer, bufsize, in) :
+     fread(main_buffer, 1, bufsize, in);
+   }
+ endptr = main_buffer + bufflength;
- bufflength = fread(buffer, 1, 3*MBUFTHIRD, in);
+ /* Unless binary-files=text, see if we have a binary file. This uses the same
- endptr = buffer + bufflength;
+ rule as GNU grep, namely, a search for a binary zero byte near the start of the
+ file. */
+ if (binary_files != BIN_TEXT)
+   {
+   binary =
+     memchr(main_buffer, 0, (bufflength > 1024)? 1024 : bufflength) != NULL;
+   if (binary && binary_files == BIN_NOMATCH) return 1;
+   }
  /* Loop while the current pointer is not at the end of the file. For large
  files, endptr will be at the end of the buffer when we are in the middle of the
-Line 785 
 way, the buffer is shifted left and re-f
+Line 1324 
 way, the buffer is shifted left and re-f
  while (ptr < endptr)
    {
-   int i, endlinelength;
+   int endlinelength;
    int mrc = 0;
-   BOOL match = FALSE;
+   int startoffset = 0;
+   BOOL match;
+   char *matchptr = ptr;
    char *t = ptr;
    size_t length, linelength;
    /* At this point, ptr is at the start of a line. We need to find the length
    of the subject string to pass to pcre_exec(). In multiline mode, it is the
    length remainder of the data in the buffer. Otherwise, it is the length of
-   the next line. After matching, we always advance by the length of the next
+   the next line, excluding the terminating newline. After matching, we always
-   line. In multiline mode the PCRE_FIRSTLINE option is used for compiling, so
+   advance by the length of the next line. In multiline mode the PCRE_FIRSTLINE
-   that any match is constrained to be in the first line. */
+   option is used for compiling, so that any match is constrained to be in the
+   first line. */
    t = end_of_line(t, endptr, &endlinelength);
    linelength = t - ptr - endlinelength;
-   length = multiline? endptr - ptr : linelength;
+   length = multiline? (size_t)(endptr - ptr) : linelength;
+   /* Check to see if the line we are looking at extends right to the very end
+   of the buffer without a line terminator. This means the line is too long to
+   handle. */
+   if (endlinelength == 0 && t == main_buffer + bufsize)
+     {
+     fprintf(stderr, "pcregrep: line %d%s%s is too long for the internal buffer\n"
+                     "pcregrep: check the --buffer-size option\n",
+                     linenumber,
+                     (filename == NULL)? "" : " of file ",
+                     (filename == NULL)? "" : filename);
+     return 2;
+     }
    /* Extra processing for Jeffrey Friedl's debugging. */
-Line 811 
 while (ptr < endptr)
+Line 1367 
 while (ptr < endptr)
        #include <time.h>
        struct timeval start_time, end_time;
        struct timezone dummy;
+       int i;
        if (jfriedl_XT)
        {
-Line 819 
 while (ptr < endptr)
+Line 1376 
 while (ptr < endptr)
            ptr = malloc(newlen + 1);
            if (!ptr) {
                    printf("out of memory");
-                   exit(2);
+                   pcregrep_exit(2);
            }
            endptr = ptr;
            strcpy(endptr, jfriedl_prefix); endptr += strlen(jfriedl_prefix);
-Line 836 
 while (ptr < endptr)
+Line 1393 
 while (ptr < endptr)
        for (i = 0; i < jfriedl_XR; i++)
-           match = (pcre_exec(pattern_list[0], hints_list[0], ptr, length, 0, 0, offsets, 99) >= 0);
+           match = (pcre_exec(patterns->compiled, patterns->hint, ptr, length, 0,
+               PCRE_NOTEMPTY, offsets, OFFSET_SIZE) >= 0);
        if (gettimeofday(&end_time, &dummy) != 0)
                perror("bad gettimeofday");
-Line 850 
 while (ptr < endptr)
+Line 1408 
 while (ptr < endptr)
    }
  #endif
+   /* We come back here after a match when the -o option (only_matching) is set,
+   in order to find any further matches in the same line. */
-   /* Run through all the patterns until one matches. Note that we don't include
+   ONLY_MATCHING_RESTART:
-   the final newline in the subject string. */
-   for (i = 0; i < pattern_count; i++)
+   /* Run through all the patterns until one matches or there is an error other
-     {
+   than NOMATCH. This code is in a subroutine so that it can be re-used for
-     mrc = pcre_exec(pattern_list[i], hints_list[i], ptr, length, 0, 0,
+   finding subsequent matches when colouring matched lines. */
-       offsets, 99);
-     if (mrc >= 0) { match = TRUE; break; }
+   match = match_patterns(matchptr, length, startoffset, offsets, &mrc);
-     if (mrc != PCRE_ERROR_NOMATCH)
-       {
-       fprintf(stderr, "pcregrep: pcre_exec() error %d while matching ", mrc);
-       if (pattern_count > 1) fprintf(stderr, "pattern number %d to ", i+1);
-       fprintf(stderr, "this line:\n");
-       fwrite(ptr, 1, linelength, stderr);   /* In case binary zero included */
-       fprintf(stderr, "\n");
-       if (error_count == 0 &&
-           (mrc == PCRE_ERROR_MATCHLIMIT || mrc == PCRE_ERROR_RECURSIONLIMIT))
-         {
-         fprintf(stderr, "pcregrep: error %d means that a resource limit "
-           "was exceeded\n", mrc);
-         fprintf(stderr, "pcregrep: check your regex for nested unlimited loops\n");
-         }
-       if (error_count++ > 20)
-         {
-         fprintf(stderr, "pcregrep: too many errors - abandoned\n");
-         exit(2);
-         }
-       match = invert;    /* No more matching; don't show the line again */
-       break;
-       }
-     }
    /* If it's a match or a not-match (as required), do what's wanted. */
-Line 897 
 while (ptr < endptr)
+Line 1433 
 while (ptr < endptr)
      if (count_only) count++;
+     /* When handling a binary file and binary-files==binary, the "binary"
+     variable will be set true (it's false in all other cases). In this
+     situation we just want to output the file name. No need to scan further. */
+     else if (binary)
+       {
+       fprintf(stdout, "Binary file %s matches\n", filename);
+       return 0;
+       }
      /* If all we want is a file name, there is no need to scan any more lines
      in the file. */
-     else if (filenames == FN_ONLY)
+     else if (filenames == FN_MATCH_ONLY)
        {
        fprintf(stdout, "%s\n", printname);
        return 0;
-Line 910 
 while (ptr < endptr)
+Line 1456 
 while (ptr < endptr)
      else if (quiet) return 0;
-     /* The --only-matching option prints just the substring that matched, and
+     /* The --only-matching option prints just the substring that matched, or a
-     does not pring any context. */
+     captured portion of it, as long as this string is not empty, and the
+     --file-offsets and --line-offsets options output offsets for the matching
+     substring (they both force --only-matching = 0). None of these options
+     prints any context. Afterwards, adjust the start and then jump back to look
+     for further matches in the same line. If we are in invert mode, however,
+     nothing is printed and we do not restart - this could still be useful
+     because the return code is set. */
-     else if (only_matching)
+     else if (only_matching >= 0)
        {
-       if (printname != NULL) fprintf(stdout, "%s:", printname);
+       if (!invert)
-       if (number) fprintf(stdout, "%d:", linenumber);
+         {
-       fwrite(ptr + offsets[0], 1, offsets[1] - offsets[0], stdout);
+         if (printname != NULL) fprintf(stdout, "%s:", printname);
-       fprintf(stdout, "\n");
+         if (number) fprintf(stdout, "%d:", linenumber);
+         if (line_offsets)
+           fprintf(stdout, "%d,%d\n", (int)(matchptr + offsets[0] - ptr),
+             offsets[1] - offsets[0]);
+         else if (file_offsets)
+           fprintf(stdout, "%d,%d\n",
+             (int)(filepos + matchptr + offsets[0] - ptr),
+             offsets[1] - offsets[0]);
+         else if (only_matching < mrc)
+           {
+           int plen = offsets[2*only_matching + 1] - offsets[2*only_matching];
+           if (plen > 0)
+             {
+             if (do_colour) fprintf(stdout, "%c[%sm", 0x1b, colour_string);
+             FWRITE(matchptr + offsets[only_matching*2], 1, plen, stdout);
+             if (do_colour) fprintf(stdout, "%c[00m", 0x1b);
+             fprintf(stdout, "\n");
+             }
+           }
+         else if (printname != NULL || number) fprintf(stdout, "\n");
+         match = FALSE;
+         if (line_buffered) fflush(stdout);
+         rc = 0;                      /* Had some success */
+         startoffset = offsets[1];    /* Restart after the match */
+         goto ONLY_MATCHING_RESTART;
+         }
        }
      /* This is the default case when none of the above options is set. We print
-Line 952 
 while (ptr < endptr)
+Line 1529 
 while (ptr < endptr)
            if (printname != NULL) fprintf(stdout, "%s-", printname);
            if (number) fprintf(stdout, "%d-", lastmatchnumber++);
            pp = end_of_line(pp, endptr, &ellength);
-           fwrite(lastmatchrestart, 1, pp - lastmatchrestart, stdout);
+           FWRITE(lastmatchrestart, 1, pp - lastmatchrestart, stdout);
            lastmatchrestart = pp;
            }
          if (lastmatchrestart != ptr) hyphenpending = TRUE;
-Line 975 
 while (ptr < endptr)
+Line 1552 
 while (ptr < endptr)
          int linecount = 0;
          char *p = ptr;
-         while (p > buffer && (lastmatchnumber == 0 || p > lastmatchrestart) &&
+         while (p > main_buffer && (lastmatchnumber == 0 || p > lastmatchrestart) &&
                 linecount < before_context)
            {
            linecount++;
-           p = previous_line(p, buffer);
+           p = previous_line(p, main_buffer);
            }
          if (lastmatchnumber > 0 && p > lastmatchrestart && !hyphenprinted)
-Line 992 
 while (ptr < endptr)
+Line 1569 
 while (ptr < endptr)
            if (printname != NULL) fprintf(stdout, "%s-", printname);
            if (number) fprintf(stdout, "%d-", linenumber - linecount--);
            pp = end_of_line(pp, endptr, &ellength);
-           fwrite(p, 1, pp - p, stdout);
+           FWRITE(p, 1, pp - p, stdout);
            p = pp;
            }
          }
-Line 1008 
 while (ptr < endptr)
+Line 1585 
 while (ptr < endptr)
        /* In multiline mode, we want to print to the end of the line in which
        the end of the matched string is found, so we adjust linelength and the
-       line number appropriately. Because the PCRE_FIRSTLINE option is set, the
+       line number appropriately, but only when there actually was a match
-       start of the match will always be before the first newline sequence. */
+       (invert not set). Because the PCRE_FIRSTLINE option is set, the start of
+       the match will always be before the first newline sequence. */
-       if (multiline)
+       if (multiline & !invert)
          {
-         int ellength;
          char *endmatch = ptr + offsets[1];
          t = ptr;
          while (t < endmatch)
            {
-           t = end_of_line(t, endptr, &ellength);
+           t = end_of_line(t, endptr, &endlinelength);
-           if (t <= endmatch) linenumber++; else break;
+           if (t < endmatch) linenumber++; else break;
            }
-         endmatch = end_of_line(endmatch, endptr, &ellength);
+         linelength = t - ptr - endlinelength;
-         linelength = endmatch - ptr - ellength;
          }
        /*** NOTE: Use only fwrite() to output the data line, so that binary
-Line 1037 
 while (ptr < endptr)
+Line 1613 
 while (ptr < endptr)
          {
          int first = S_arg * 2;
          int last  = first + 1;
-         fwrite(ptr, 1, offsets[first], stdout);
+         FWRITE(ptr, 1, offsets[first], stdout);
          fprintf(stdout, "X");
-         fwrite(ptr + offsets[last], 1, linelength - offsets[last], stdout);
+         FWRITE(ptr + offsets[last], 1, linelength - offsets[last], stdout);
          }
        else
  #endif
-       /* We have to split the line(s) up if colouring. */
+       /* We have to split the line(s) up if colouring, and search for further
+       matches, but not of course if the line is a non-match. */
-       if (do_colour)
+       if (do_colour && !invert)
          {
-         fwrite(ptr, 1, offsets[0], stdout);
+         int plength;
+         FWRITE(ptr, 1, offsets[0], stdout);
          fprintf(stdout, "%c[%sm", 0x1b, colour_string);
-         fwrite(ptr + offsets[0], 1, offsets[1] - offsets[0], stdout);
+         FWRITE(ptr + offsets[0], 1, offsets[1] - offsets[0], stdout);
          fprintf(stdout, "%c[00m", 0x1b);
-         fwrite(ptr + offsets[1], 1, linelength - offsets[1], stdout);
+         for (;;)
+           {
+           startoffset = offsets[1];
+           if (startoffset >= (int)linelength + endlinelength ||
+               !match_patterns(matchptr, length, startoffset, offsets, &mrc))
+             break;
+           FWRITE(matchptr + startoffset, 1, offsets[0] - startoffset, stdout);
+           fprintf(stdout, "%c[%sm", 0x1b, colour_string);
+           FWRITE(matchptr + offsets[0], 1, offsets[1] - offsets[0], stdout);
+           fprintf(stdout, "%c[00m", 0x1b);
+           }
+         /* In multiline mode, we may have already printed the complete line
+         and its line-ending characters (if they matched the pattern), so there
+         may be no more to print. */
+         plength = (int)((linelength + endlinelength) - startoffset);
+         if (plength > 0) FWRITE(ptr + startoffset, 1, plength, stdout);
          }
-       else fwrite(ptr, 1, linelength + endlinelength, stdout);
+       /* Not colouring; no need to search for further matches */
+       else FWRITE(ptr, 1, linelength + endlinelength, stdout);
        }
-     /* End of doing what has to be done for a match */
+     /* End of doing what has to be done for a match. If --line-buffered was
+     given, flush the output. */
+     if (line_buffered) fflush(stdout);
      rc = 0;    /* Had some success */
      /* Remember where the last match happened for after_context. We remember
-Line 1068 
 while (ptr < endptr)
+Line 1668 
 while (ptr < endptr)
      lastmatchnumber = linenumber + 1;
      }
-   /* Advance to after the newline and increment the line number. */
+   /* For a match in multiline inverted mode (which of course did not cause
+   anything to be printed), we have to move on to the end of the match before
+   proceeding. */
+   if (multiline && invert && match)
+     {
+     int ellength;
+     char *endmatch = ptr + offsets[1];
+     t = ptr;
+     while (t < endmatch)
+       {
+       t = end_of_line(t, endptr, &ellength);
+       if (t <= endmatch) linenumber++; else break;
+       }
+     endmatch = end_of_line(endmatch, endptr, &ellength);
+     linelength = endmatch - ptr - ellength;
+     }
+   /* Advance to after the newline and increment the line number. The file
+   offset to the current line is maintained in filepos. */
    ptr += linelength + endlinelength;
+   filepos += (int)(linelength + endlinelength);
    linenumber++;
+   /* If input is line buffered, and the buffer is not yet full, read another
+   line and add it into the buffer. */
+   if (input_line_buffered && bufflength < (size_t)bufsize)
+     {
+     int add = read_one_line(ptr, bufsize - (int)(ptr - main_buffer), in);
+     bufflength += add;
+     endptr += add;
+     }
    /* If we haven't yet reached the end of the file (the buffer is full), and
    the current point is in the top 1/3 of the buffer, slide the buffer down by
 /3 and refill it. Before we do this, if some unprinted "after" lines are
    about to be lost, print them. */
-   if (bufflength >= sizeof(buffer) && ptr > buffer + 2*MBUFTHIRD)
+   if (bufflength >= (size_t)bufsize && ptr > main_buffer + 2*bufthird)
      {
      if (after_context > 0 &&
          lastmatchnumber > 0 &&
-         lastmatchrestart < buffer + MBUFTHIRD)
+         lastmatchrestart < main_buffer + bufthird)
        {
        do_after_lines(lastmatchnumber, lastmatchrestart, endptr, printname);
        lastmatchnumber = 0;
-Line 1090 
 while (ptr < endptr)
+Line 1720 
 while (ptr < endptr)
      /* Now do the shuffle */
-     memmove(buffer, buffer + MBUFTHIRD, 2*MBUFTHIRD);
+     memmove(main_buffer, main_buffer + bufthird, 2*bufthird);
-     ptr -= MBUFTHIRD;
+     ptr -= bufthird;
-     bufflength = 2*MBUFTHIRD + fread(buffer + 2*MBUFTHIRD, 1, MBUFTHIRD, in);
-     endptr = buffer + bufflength;
+ #ifdef SUPPORT_LIBZ
+     if (frtype == FR_LIBZ)
+       bufflength = 2*bufthird +
+         gzread (ingz, main_buffer + 2*bufthird, bufthird);
+     else
+ #endif
+ #ifdef SUPPORT_LIBBZ2
+     if (frtype == FR_LIBBZ2)
+       bufflength = 2*bufthird +
+         BZ2_bzread(inbz2, main_buffer + 2*bufthird, bufthird);
+     else
+ #endif
+     bufflength = 2*bufthird +
+       (input_line_buffered?
+        read_one_line(main_buffer + 2*bufthird, bufthird, in) :
+        fread(main_buffer + 2*bufthird, 1, bufthird, in));
+     endptr = main_buffer + bufflength;
      /* Adjust any last match point */
-     if (lastmatchnumber > 0) lastmatchrestart -= MBUFTHIRD;
+     if (lastmatchnumber > 0) lastmatchrestart -= bufthird;
      }
    }     /* Loop through the whole file */
  /* End of file; print final "after" lines if wanted; do_after_lines sets
  hyphenpending if it prints something. */
- if (!only_matching && !count_only)
+ if (only_matching < 0 && !count_only)
    {
    do_after_lines(lastmatchnumber, lastmatchrestart, endptr, printname);
    hyphenpending |= endhyphenpending;
-Line 1123 
 if (filenames == FN_NOMATCH_ONLY)
+Line 1771 
 if (filenames == FN_NOMATCH_ONLY)
  if (count_only)
    {
-   if (printname != NULL) fprintf(stdout, "%s:", printname);
+   if (count > 0 || !omit_zero_count)
-   fprintf(stdout, "%d\n", count);
+     {
+     if (printname != NULL && filenames != FN_NONE)
+       fprintf(stdout, "%s:", printname);
+     fprintf(stdout, "%d\n", count);
+     }
    }
  return rc;
-Line 1144 
 Arguments:
+Line 1796 
 Arguments:
    dir_recurse       TRUE if recursing is wanted (-r or -drecurse)
    only_one_at_top   TRUE if the path is the only one at toplevel
- Returns:   0 if there was at least one match
+ Returns:  -1 the file/directory was skipped
+if there was at least one match
 if there were no matches
 there was some kind of error
-Line 1155 
 static int
+Line 1808 
 static int
  grep_or_recurse(char *pathname, BOOL dir_recurse, BOOL only_one_at_top)
  {
  int rc = 1;
- int sep;
+ int frtype;
- FILE *in;
+ void *handle;
+ char *lastcomp;
+ FILE *in = NULL;           /* Ensure initialized */
+ #ifdef SUPPORT_LIBZ
+ gzFile ingz = NULL;
+ #endif
+ #ifdef SUPPORT_LIBBZ2
+ BZFILE *inbz2 = NULL;
+ #endif
+ #if defined SUPPORT_LIBZ || defined SUPPORT_LIBBZ2
+ int pathlen;
+ #endif
  /* If the file name is "-" we scan stdin */
  if (strcmp(pathname, "-") == 0)
    {
-   return pcregrep(stdin,
+   return pcregrep(stdin, FR_PLAIN, stdin_name,
      (filenames > FN_DEFAULT || (filenames == FN_DEFAULT && !only_one_at_top))?
        stdin_name : NULL);
    }
+ /* Inclusion and exclusion: --include-dir and --exclude-dir apply only to
+ directories, whereas --include and --exclude apply to everything else. The test
+ is against the final component of the path. */
+ lastcomp = strrchr(pathname, FILESEP);
+ lastcomp = (lastcomp == NULL)? pathname : lastcomp + 1;
+ /* If the file is a directory, skip if not recursing or if explicitly excluded.
+ Otherwise, scan the directory and recurse for each path within it. The scanning
+ code is localized so it can be made system-specific. */
+ if (isdirectory(pathname))
+   {
+   if (dee_action == dee_SKIP ||
+       !test_incexc(lastcomp, include_dir_patterns, exclude_dir_patterns))
+     return -1;
- /* If the file is a directory, skip if skipping or if we are recursing, scan
- each file within it, subject to any include or exclude patterns that were set.
- The scanning code is localized so it can be made system-specific. */
- if ((sep = isdirectory(pathname)) != 0)
-   {
-   if (dee_action == dee_SKIP) return 1;
    if (dee_action == dee_RECURSE)
      {
      char buffer[1024];
-Line 1191 
 if ((sep = isdirectory(pathname)) != 0)
+Line 1867 
 if ((sep = isdirectory(pathname)) != 0)
      while ((nextfile = readdirectory(dir)) != NULL)
        {
-       int frc, blen;
+       int frc;
-       sprintf(buffer, "%.512s%c%.128s", pathname, sep, nextfile);
+       sprintf(buffer, "%.512s%c%.128s", pathname, FILESEP, nextfile);
-       blen = strlen(buffer);
-       if (exclude_compiled != NULL &&
-           pcre_exec(exclude_compiled, NULL, buffer, blen, 0, 0, NULL, 0) >= 0)
-         continue;
-       if (include_compiled != NULL &&
-           pcre_exec(include_compiled, NULL, buffer, blen, 0, 0, NULL, 0) < 0)
-         continue;
        frc = grep_or_recurse(buffer, dir_recurse, FALSE);
        if (frc > 1) rc = frc;
         else if (frc == 0 && rc == 1) rc = 0;
-Line 1214 
 if ((sep = isdirectory(pathname)) != 0)
+Line 1880 
 if ((sep = isdirectory(pathname)) != 0)
    }
  /* If the file is not a directory and not a regular file, skip it if that's
- been requested. */
+ been requested. Otherwise, check for explicit include/exclude. */
- else if (!isregfile(pathname) && DEE_action == DEE_SKIP) return 1;
+ else if ((!isregfile(pathname) && DEE_action == DEE_SKIP) ||
+           !test_incexc(lastcomp, include_patterns, exclude_patterns))
+         return -1;
  /* Control reaches here if we have a regular file, or if we have a directory
  and recursion or skipping was not requested, or if we have anything else and
-Line 1224 
 skipping was not requested. The scan pro
+Line 1892 
 skipping was not requested. The scan pro
  argument at top level, we don't show the file name, unless we are only showing
  the file name, or the filename was forced (-H). */
- in = fopen(pathname, "r");
+ #if defined SUPPORT_LIBZ || defined SUPPORT_LIBBZ2
- if (in == NULL)
+ pathlen = (int)(strlen(pathname));
+ #endif
+ /* Open using zlib if it is supported and the file name ends with .gz. */
+ #ifdef SUPPORT_LIBZ
+ if (pathlen > 3 && strcmp(pathname + pathlen - 3, ".gz") == 0)
+   {
+   ingz = gzopen(pathname, "rb");
+   if (ingz == NULL)
+     {
+     if (!silent)
+       fprintf(stderr, "pcregrep: Failed to open %s: %s\n", pathname,
+         strerror(errno));
+     return 2;
+     }
+   handle = (void *)ingz;
+   frtype = FR_LIBZ;
+   }
+ else
+ #endif
+ /* Otherwise open with bz2lib if it is supported and the name ends with .bz2. */
+ #ifdef SUPPORT_LIBBZ2
+ if (pathlen > 4 && strcmp(pathname + pathlen - 4, ".bz2") == 0)
+   {
+   inbz2 = BZ2_bzopen(pathname, "rb");
+   handle = (void *)inbz2;
+   frtype = FR_LIBBZ2;
+   }
+ else
+ #endif
+ /* Otherwise use plain fopen(). The label is so that we can come back here if
+ an attempt to read a .bz2 file indicates that it really is a plain file. */
+ #ifdef SUPPORT_LIBBZ2
+ PLAIN_FILE:
+ #endif
+   {
+   in = fopen(pathname, "rb");
+   handle = (void *)in;
+   frtype = FR_PLAIN;
+   }
+ /* All the opening methods return errno when they fail. */
+ if (handle == NULL)
    {
    if (!silent)
      fprintf(stderr, "pcregrep: Failed to open %s: %s\n", pathname,
-Line 1233 
 if (in == NULL)
+Line 1949 
 if (in == NULL)
    return 2;
    }
- rc = pcregrep(in, (filenames > FN_DEFAULT ||
+ /* Now grep the file */
+ rc = pcregrep(handle, frtype, pathname, (filenames > FN_DEFAULT ||
    (filenames == FN_DEFAULT && !only_one_at_top))? pathname : NULL);
+ /* Close in an appropriate manner. */
+ #ifdef SUPPORT_LIBZ
+ if (frtype == FR_LIBZ)
+   gzclose(ingz);
+ else
+ #endif
+ /* If it is a .bz2 file and the result is 3, it means that the first attempt to
+ read failed. If the error indicates that the file isn't in fact bzipped, try
+ again as a normal file. */
+ #ifdef SUPPORT_LIBBZ2
+ if (frtype == FR_LIBBZ2)
+   {
+   if (rc == 3)
+     {
+     int errnum;
+     const char *err = BZ2_bzerror(inbz2, &errnum);
+     if (errnum == BZ_DATA_ERROR_MAGIC)
+       {
+       BZ2_bzclose(inbz2);
+       goto PLAIN_FILE;
+       }
+     else if (!silent)
+       fprintf(stderr, "pcregrep: Failed to read %s using bzlib: %s\n",
+         pathname, err);
+     rc = 2;    /* The normal "something went wrong" code */
+     }
+   BZ2_bzclose(inbz2);
+   }
+ else
+ #endif
+ /* Normal file close */
  fclose(in);
+ /* Pass back the yield from pcregrep(). */
  return rc;
  }
-Line 1257 
 for (op = optionlist; op->one_char != 0;
+Line 2014 
 for (op = optionlist; op->one_char != 0;
    if (op->one_char > 0) fprintf(stderr, "%c", op->one_char);
    }
  fprintf(stderr, "] [long options] [pattern] [files]\n");
- fprintf(stderr, "Type `pcregrep --help' for more information.\n");
+ fprintf(stderr, "Type `pcregrep --help' for more information and the long "
+   "options.\n");
  return rc;
  }
-Line 1276 
 option_item *op;
+Line 2034 
 option_item *op;
  printf("Usage: pcregrep [OPTION]... [PATTERN] [FILE1 FILE2 ...]\n");
  printf("Search for PATTERN in each FILE or standard input.\n");
  printf("PATTERN must be present if neither -e nor -f is used.\n");
- printf("\"-\" can be used as a file name to mean STDIN.\n\n");
+ printf("\"-\" can be used as a file name to mean STDIN.\n");
- printf("Example: pcregrep -i 'hello.*world' menu.h main.c\n\n");
+ #ifdef SUPPORT_LIBZ
+ printf("Files whose names end in .gz are read using zlib.\n");
+ #endif
+ #ifdef SUPPORT_LIBBZ2
+ printf("Files whose names end in .bz2 are read using bzlib2.\n");
+ #endif
+ #if defined SUPPORT_LIBZ || defined SUPPORT_LIBBZ2
+ printf("Other files and the standard input are read as plain files.\n\n");
+ #else
+ printf("All files are read as plain files, without any interpretation.\n\n");
+ #endif
+ printf("Example: pcregrep -i 'hello.*world' menu.h main.c\n\n");
  printf("Options:\n");
  for (op = optionlist; op->one_char != 0; op++)
    {
    int n;
    char s[4];
-   if (op->one_char > 0) sprintf(s, "-%c,", op->one_char); else strcpy(s, "   ");
-   printf("  %s --%s%n", s, op->long_name, &n);
+   /* Two options were accidentally implemented and documented with underscores
-   n = 30 - n;
+   instead of hyphens in their names, something that was not noticed for quite a
+   few releases. When fixing this, I left the underscored versions in the list
+   in case people were using them. However, we don't want to display them in the
+   help data. There are no other options that contain underscores, and we do not
+   expect ever to implement such options. Therefore, just omit any option that
+   contains an underscore. */
+   if (strchr(op->long_name, '_') != NULL) continue;
+   if (op->one_char > 0 && (op->long_name)[0] == 0)
+     n = 31 - printf("  -%c", op->one_char);
+   else
+     {
+     if (op->one_char > 0) sprintf(s, "-%c,", op->one_char);
+       else strcpy(s, "   ");
+     n = 31 - printf("  %s --%s", s, op->long_name);
+     }
    if (n < 1) n = 1;
-   printf("%.*s%s\n", n, "                    ", op->help_text);
+   printf("%.*s%s\n", n, "                           ", op->help_text);
    }
- printf("\nWhen reading patterns from a file instead of using a command line option,\n");
+ printf("\nNumbers may be followed by K or M, e.g. --buffer-size=100K.\n");
- printf("trailing white space is removed and blank lines are ignored.\n");
+ printf("The default value for --buffer-size is %d.\n", PCREGREP_BUFSIZE);
- printf("There is a maximum of %d patterns.\n", MAX_PATTERN_COUNT);
+ printf("When reading patterns or file names from a file, trailing white\n");
+ printf("space is removed and blank lines are ignored.\n");
+ printf("The maximum size of any pattern is %d bytes.\n", MAXPATLEN);
  printf("\nWith no FILEs, read standard input. If fewer than two FILEs given, assume -h.\n");
  printf("Exit status is 0 if any matches, 1 if no matches, and 2 if trouble.\n");
-Line 1312 
 handle_option(int letter, int options)
+Line 2103 
 handle_option(int letter, int options)
  {
  switch(letter)
    {
-   case N_HELP: help(); exit(0);
+   case N_FOFFSETS: file_offsets = TRUE; break;
+   case N_HELP: help(); pcregrep_exit(0);
+   case N_LBUFFER: line_buffered = TRUE; break;
+   case N_LOFFSETS: line_offsets = number = TRUE; break;
+   case N_NOJIT: study_options &= ~PCRE_STUDY_JIT_COMPILE; break;
+   case 'a': binary_files = BIN_TEXT; break;
    case 'c': count_only = TRUE; break;
    case 'F': process_options |= PO_FIXED_STRINGS; break;
    case 'H': filenames = FN_FORCE; break;
+   case 'I': binary_files = BIN_NOMATCH; break;
    case 'h': filenames = FN_NONE; break;
    case 'i': options |= PCRE_CASELESS; break;
-   case 'l': filenames = FN_ONLY; break;
+   case 'l': omit_zero_count = TRUE; filenames = FN_MATCH_ONLY; break;
    case 'L': filenames = FN_NOMATCH_ONLY; break;
    case 'M': multiline = TRUE; options |= PCRE_MULTILINE|PCRE_FIRSTLINE; break;
    case 'n': number = TRUE; break;
-   case 'o': only_matching = TRUE; break;
+   case 'o': only_matching = 0; break;
    case 'q': quiet = TRUE; break;
    case 'r': dee_action = dee_RECURSE; break;
    case 's': silent = TRUE; break;
-Line 1332 
 switch(letter)
+Line 2129 
 switch(letter)
    case 'x': process_options |= PO_LINE_MATCH; break;
    case 'V':
-   fprintf(stderr, "pcregrep version %s\n", pcre_version());
+   fprintf(stdout, "pcregrep version %s\n", pcre_version());
-   exit(0);
+   pcregrep_exit(0);
    break;
    default:
    fprintf(stderr, "pcregrep: Unknown option -%c\n", letter);
-   exit(usage(2));
+   pcregrep_exit(usage(2));
    }
  return options;
-Line 1376 
 return buffer;
+Line 2173 
 return buffer;
  *          Compile a single pattern              *
  *************************************************/
- /* When the -F option has been used, this is called for each substring.
+ /* Do nothing if the pattern has already been compiled. This is the case for
- Otherwise it's called for each supplied pattern.
+ include/exclude patterns read from a file.
+ When the -F option has been used, each "pattern" may be a list of strings,
+ separated by line breaks. They will be matched literally. We split such a
+ string and compile the first substring, inserting an additional block into the
+ pattern chain.
  Arguments:
-   pattern        the pattern string
+   p              points to the pattern block
    options        the PCRE options
-   filename       the file name, or NULL for a command-line pattern
+   popts          the processing options
+   fromfile       TRUE if the pattern was read from a file
+   fromtext       file name or identifying text (e.g. "include")
    count          0 if this is the only command line pattern, or
                   number of the command line pattern, or
                   linenumber for a pattern from a file
-Line 1391 
 Returns:         TRUE on success, FALSE
+Line 2195 
 Returns:         TRUE on success, FALSE
  */
  static BOOL
- compile_single_pattern(char *pattern, int options, char *filename, int count)
+ compile_pattern(patstr *p, int options, int popts, int fromfile,
+   const char *fromtext, int count)
  {
- char buffer[MBUFTHIRD + 16];
+ char buffer[PATBUFSIZE];
  const char *error;
+ char *ps = p->string;
+ int patlen = strlen(ps);
  int errptr;
- if (pattern_count >= MAX_PATTERN_COUNT)
+ if (p->compiled != NULL) return TRUE;
+ if ((popts & PO_FIXED_STRINGS) != 0)
    {
-   fprintf(stderr, "pcregrep: Too many %spatterns (max %d)\n",
+   int ellength;
-     (filename == NULL)? "command-line " : "", MAX_PATTERN_COUNT);
+   char *eop = ps + patlen;
-   return FALSE;
+   char *pe = end_of_line(ps, eop, &ellength);
+   if (ellength != 0)
+     {
+     if (add_pattern(pe, p) == NULL) return FALSE;
+     patlen = (int)(pe - ps - ellength);
+     }
    }
- sprintf(buffer, "%s%.*s%s", prefix[process_options], MBUFTHIRD, pattern,
+ sprintf(buffer, "%s%.*s%s", prefix[popts], patlen, ps, suffix[popts]);
-   suffix[process_options]);
+ p->compiled = pcre_compile(buffer, options, &error, &errptr, pcretables);
- pattern_list[pattern_count] =
+ if (p->compiled != NULL) return TRUE;
-   pcre_compile(buffer, options, &error, &errptr, pcretables);
- if (pattern_list[pattern_count++] != NULL) return TRUE;
  /* Handle compile errors */
- errptr -= (int)strlen(prefix[process_options]);
+ errptr -= (int)strlen(prefix[popts]);
- if (errptr > (int)strlen(pattern)) errptr = (int)strlen(pattern);
+ if (errptr > patlen) errptr = patlen;
- if (filename == NULL)
+ if (fromfile)
    {
-   if (count == 0)
+   fprintf(stderr, "pcregrep: Error in regex in line %d of %s "
-     fprintf(stderr, "pcregrep: Error in command-line regex "
+     "at offset %d: %s\n", count, fromtext, errptr, error);
-       "at offset %d: %s\n", errptr, error);
-   else
-     fprintf(stderr, "pcregrep: Error in %s command-line regex "
-       "at offset %d: %s\n", ordin(count), errptr, error);
    }
  else
    {
-   fprintf(stderr, "pcregrep: Error in regex in line %d of %s "
+   if (count == 0)
-     "at offset %d: %s\n", count, filename, errptr, error);
+     fprintf(stderr, "pcregrep: Error in %s regex at offset %d: %s\n",
+       fromtext, errptr, error);
+   else
+     fprintf(stderr, "pcregrep: Error in %s %s regex at offset %d: %s\n",
+       ordin(count), fromtext, errptr, error);
    }
  return FALSE;
-Line 1436 
 return FALSE;
+Line 2249 
 return FALSE;
  /*************************************************
- *           Compile one supplied pattern         *
+ *     Read and compile a file of patterns        *
  *************************************************/
- /* When the -F option has been used, each string may be a list of strings,
+ /* This is used for --filelist, --include-from, and --exclude-from.
- separated by line breaks. They will be matched literally.
  Arguments:
-   pattern        the pattern string
+   name         the name of the file; "-" is stdin
-   options        the PCRE options
+   patptr       pointer to the pattern chain anchor
-   filename       the file name, or NULL for a command-line pattern
+   patlastptr   pointer to the last pattern pointer
-   count          0 if this is the only command line pattern, or
+   popts        the process options to pass to pattern_compile()
-                  number of the command line pattern, or
-                  linenumber for a pattern from a file
- Returns:         TRUE on success, FALSE after an error
+ Returns:       TRUE if all went well
  */
  static BOOL
- compile_pattern(char *pattern, int options, char *filename, int count)
+ read_pattern_file(char *name, patstr **patptr, patstr **patlastptr, int popts)
  {
- if ((process_options & PO_FIXED_STRINGS) != 0)
+ int linenumber = 0;
+ FILE *f;
+ char *filename;
+ char buffer[PATBUFSIZE];
+ if (strcmp(name, "-") == 0)
    {
-   char *eop = pattern + strlen(pattern);
+   f = stdin;
-   char buffer[MBUFTHIRD];
+   filename = stdin_name;
+   }
+ else
+   {
+   f = fopen(name, "r");
+   if (f == NULL)
+     {
+     fprintf(stderr, "pcregrep: Failed to open %s: %s\n", name, strerror(errno));
+     return FALSE;
+     }
+   filename = name;
+   }
+ while (fgets(buffer, PATBUFSIZE, f) != NULL)
+   {
+   char *s = buffer + (int)strlen(buffer);
+   while (s > buffer && isspace((unsigned char)(s[-1]))) s--;
+   *s = 0;
+   linenumber++;
+   if (buffer[0] == 0) continue;   /* Skip blank lines */
+   /* Note: this call to add_pattern() puts a pointer to the local variable
+   "buffer" into the pattern chain. However, that pointer is used only when
+   compiling the pattern, which happens immediately below, so we flatten it
+   afterwards, as a precaution against any later code trying to use it. */
+   *patlastptr = add_pattern(buffer, *patlastptr);
+   if (*patlastptr == NULL) return FALSE;
+   if (*patptr == NULL) *patptr = *patlastptr;
+   /* This loop is needed because compiling a "pattern" when -F is set may add
+   on additional literal patterns if the original contains a newline. In the
+   common case, it never will, because fgets() stops at a newline. However,
+   the -N option can be used to give pcregrep a different newline setting. */
    for(;;)
      {
-     int ellength;
+     if (!compile_pattern(*patlastptr, pcre_options, popts, TRUE, filename,
-     char *p = end_of_line(pattern, eop, &ellength);
+         linenumber))
-     if (ellength == 0)
-       return compile_single_pattern(pattern, options, filename, count);
-     sprintf(buffer, "%.*s", p - pattern - ellength, pattern);
-     pattern = p;
-     if (!compile_single_pattern(buffer, options, filename, count))
        return FALSE;
+     (*patlastptr)->string = NULL;            /* Insurance */
+     if ((*patlastptr)->next == NULL) break;
+     *patlastptr = (*patlastptr)->next;
      }
    }
- else return compile_single_pattern(pattern, options, filename, count);
+ if (f != stdin) fclose(f);
+ return TRUE;
  }
-Line 1488 
 main(int argc, char **argv)
+Line 2337 
 main(int argc, char **argv)
  {
  int i, j;
  int rc = 1;
- int pcre_options = 0;
- int cmd_pattern_count = 0;
- int errptr;
  BOOL only_one_at_top;
- char *patterns[MAX_PATTERN_COUNT];
+ patstr *cp;
+ fnstr *fn;
  const char *locale_from = "--locale";
  const char *error;
+ #ifdef SUPPORT_PCREGREP_JIT
+ pcre_jit_stack *jit_stack = NULL;
+ #endif
  /* Set the default line ending value from the default in the PCRE library;
  "lf", "cr", "crlf", and "any" are supported. Anything else is treated as "lf".
- */
+ Note that the return values from pcre_config(), though derived from the ASCII
+ codes, are the same in EBCDIC environments, so we must use the actual values
+ rather than escapes such as as '\r'. */
  (void)pcre_config(PCRE_CONFIG_NEWLINE, &i);
  switch(i)
    {
-   default:                 newline = (char *)"lf"; break;
+   default:               newline = (char *)"lf"; break;
-   case '\r':               newline = (char *)"cr"; break;
+   case 13:               newline = (char *)"cr"; break;
-   case ('\r' << 8) | '\n': newline = (char *)"crlf"; break;
+   case (13 << 8) | 10:   newline = (char *)"crlf"; break;
-   case -1:                 newline = (char *)"any"; break;
+   case -1:               newline = (char *)"any"; break;
+   case -2:               newline = (char *)"anycrlf"; break;
    }
  /* Process the options */
-Line 1525 
 for (i = 1; i < argc; i++)
+Line 2379 
 for (i = 1; i < argc; i++)
    if (argv[i][1] == 0)
      {
-     if (pattern_filename != NULL || pattern_count > 0) break;
+     if (pattern_files != NULL || patterns != NULL) break;
-       else exit(usage(2));
+       else pcregrep_exit(usage(2));
      }
    /* Handle a long name option, or -- to terminate the options */
-Line 1548 
 for (i = 1; i < argc; i++)
+Line 2402 
 for (i = 1; i < argc; i++)
      Some options have variations in the long name spelling: specifically, we
      allow "regexp" because GNU grep allows it, though I personally go along
      with Jeffrey Friedl and Larry Wall in preferring "regex" without the "p".
-     These options are entered in the table as "regex(p)". No option is in both
+     These options are entered in the table as "regex(p)". Options can be in
-     these categories, fortunately. */
+     both these categories. */
      for (op = optionlist; op->one_char != 0; op++)
        {
        char *opbra = strchr(op->long_name, '(');
        char *equals = strchr(op->long_name, '=');
-       if (opbra == NULL)     /* Not a (p) case */
+       /* Handle options with only one spelling of the name */
+       if (opbra == NULL)     /* Does not contain '(' */
          {
          if (equals == NULL)  /* Not thing=data case */
            {
-Line 1563 
 for (i = 1; i < argc; i++)
+Line 2420 
 for (i = 1; i < argc; i++)
            }
          else                 /* Special case xxx=data */
            {
-           int oplen = equals - op->long_name;
+           int oplen = (int)(equals - op->long_name);
-           int arglen = (argequals == NULL)? strlen(arg) : argequals - arg;
+           int arglen = (argequals == NULL)?
+             (int)strlen(arg) : (int)(argequals - arg);
            if (oplen == arglen && strncmp(arg, op->long_name, oplen) == 0)
              {
              option_data = arg + arglen;
-Line 1577 
 for (i = 1; i < argc; i++)
+Line 2435 
 for (i = 1; i < argc; i++)
              }
            }
          }
-       else                   /* Special case xxxx(p) */
+       /* Handle options with an alternate spelling of the name */
+       else
          {
          char buff1[24];
          char buff2[24];
-         int baselen = opbra - op->long_name;
+         int baselen = (int)(opbra - op->long_name);
+         int fulllen = (int)(strchr(op->long_name, ')') - op->long_name + 1);
+         int arglen = (argequals == NULL || equals == NULL)?
+           (int)strlen(arg) : (int)(argequals - arg);
          sprintf(buff1, "%.*s", baselen, op->long_name);
-         sprintf(buff2, "%s%.*s", buff1, strlen(op->long_name) - baselen - 2,
+         sprintf(buff2, "%s%.*s", buff1, fulllen - baselen - 2, opbra + 1);
-           opbra + 1);
-         if (strcmp(arg, buff1) == 0 || strcmp(arg, buff2) == 0)
+         if (strncmp(arg, buff1, arglen) == 0 ||
+            strncmp(arg, buff2, arglen) == 0)
+           {
+           if (equals != NULL && argequals != NULL)
+             {
+             option_data = argequals;
+             if (*option_data == '=')
+               {
+               option_data++;
+               longopwasequals = TRUE;
+               }
+             }
            break;
+           }
          }
        }
      if (op->one_char == 0)
        {
        fprintf(stderr, "pcregrep: Unknown option %s\n", argv[i]);
-       exit(usage(2));
+       pcregrep_exit(usage(2));
        }
      }
    /* Jeffrey Friedl's debugging harness uses these additional options which
    are not in the right form for putting in the option table because they use
    only one hyphen, yet are more than one character long. By putting them
-Line 1631 
 for (i = 1; i < argc; i++)
+Line 2508 
 for (i = 1; i < argc; i++)
      while (*s != 0)
        {
        for (op = optionlist; op->one_char != 0; op++)
-         { if (*s == op->one_char) break; }
+         {
+         if (*s == op->one_char) break;
+         }
        if (op->one_char == 0)
          {
          fprintf(stderr, "pcregrep: Unknown option letter '%c' in \"%s\"\n",
            *s, argv[i]);
-         exit(usage(2));
+         pcregrep_exit(usage(2));
+         }
+       /* Check for a single-character option that has data: OP_OP_NUMBER
+       is used for one that either has a numerical number or defaults, i.e. the
+       data is optional. If a digit follows, there is data; if not, carry on
+       with other single-character options in the same string. */
+       option_data = s+1;
+       if (op->type == OP_OP_NUMBER)
+         {
+         if (isdigit((unsigned char)s[1])) break;
          }
-       if (op->type != OP_NODATA || s[1] == 0)
+       else   /* Check for end or a dataless option */
          {
-         option_data = s+1;
+         if (op->type != OP_NODATA || s[1] == 0) break;
-         break;
          }
+       /* Handle a single-character option with no data, then loop for the
+       next character in the string. */
        pcre_options = handle_option(*s++, pcre_options);
        }
      }
-Line 1659 
 for (i = 1; i < argc; i++)
+Line 2552 
 for (i = 1; i < argc; i++)
    /* If the option type is OP_OP_STRING or OP_OP_NUMBER, it's an option that
    either has a value or defaults to something. It cannot have data in a
-   separate item. At the moment, the only such options are "colo(u)r" and
+   separate item. At the moment, the only such options are "colo(u)r",
-   Jeffrey Friedl's special -S debugging option. */
+   "only-matching", and Jeffrey Friedl's special -S debugging option. */
    if (*option_data == 0 &&
        (op->type == OP_OP_STRING || op->type == OP_OP_NUMBER))
-Line 1670 
 for (i = 1; i < argc; i++)
+Line 2563 
 for (i = 1; i < argc; i++)
        case N_COLOUR:
        colour_option = (char *)"auto";
        break;
+       case 'o':
+       only_matching = 0;
+       break;
  #ifdef JFRIEDL_DEBUG
        case 'S':
        S_arg = 0;
-Line 1686 
 for (i = 1; i < argc; i++)
+Line 2584 
 for (i = 1; i < argc; i++)
      if (i >= argc - 1 || longopwasequals)
        {
        fprintf(stderr, "pcregrep: Data missing after %s\n", argv[i]);
-       exit(usage(2));
+       pcregrep_exit(usage(2));
        }
      option_data = argv[++i];
      }
-   /* If the option type is OP_PATLIST, it's the -e option, which can be called
+   /* If the option type is OP_PATLIST, it's the -e option, or one of the
-   multiple times to create a list of patterns. */
+   include/exclude options, which can be called multiple times to create lists
+   of patterns. */
    if (op->type == OP_PATLIST)
+      {
+      patdatastr *pd = (patdatastr *)op->dataptr;
+      *(pd->lastptr) = add_pattern(option_data, *(pd->lastptr));
+      if (*(pd->lastptr) == NULL) goto EXIT2;
+      if (*(pd->anchor) == NULL) *(pd->anchor) = *(pd->lastptr);
+      }
+   /* If the option type is OP_FILELIST, it's one of the options that names a
+   file. */
+   else if (op->type == OP_FILELIST)
+     {
+     fndatastr *fd = (fndatastr *)op->dataptr;
+     fn = (fnstr *)malloc(sizeof(fnstr));
+     if (fn == NULL)
+       {
+       fprintf(stderr, "pcregrep: malloc failed\n");
+       goto EXIT2;
+       }
+     fn->next = NULL;
+     fn->name = option_data;
+     if (*(fd->anchor) == NULL)
+       *(fd->anchor) = fn;
+     else
+       (*(fd->lastptr))->next = fn;
+     *(fd->lastptr) = fn;
+     }
+   /* Handle OP_BINARY_FILES */
+   else if (op->type == OP_BINFILES)
      {
-     if (cmd_pattern_count >= MAX_PATTERN_COUNT)
+     if (strcmp(option_data, "binary") == 0)
+       binary_files = BIN_BINARY;
+     else if (strcmp(option_data, "without-match") == 0)
+       binary_files = BIN_NOMATCH;
+     else if (strcmp(option_data, "text") == 0)
+       binary_files = BIN_TEXT;
+     else
        {
-       fprintf(stderr, "pcregrep: Too many command-line patterns (max %d)\n",
+       fprintf(stderr, "pcregrep: unknown value \"%s\" for binary-files\n",
-         MAX_PATTERN_COUNT);
+         option_data);
-       return 2;
+       pcregrep_exit(usage(2));
        }
-     patterns[cmd_pattern_count++] = option_data;
      }
    /* Otherwise, deal with single string or numeric data values. */
-   else if (op->type != OP_NUMBER && op->type != OP_OP_NUMBER)
+   else if (op->type != OP_NUMBER && op->type != OP_LONGNUMBER &&
+            op->type != OP_OP_NUMBER)
      {
      *((char **)op->dataptr) = option_data;
      }
+   /* Avoid the use of strtoul() because SunOS4 doesn't have it. This is used
+   only for unpicking arguments, so just keep it simple. */
    else
      {
-     char *endptr;
+     unsigned long int n = 0;
-     int n = strtoul(option_data, &endptr, 10);
+     char *endptr = option_data;
+     while (*endptr != 0 && isspace((unsigned char)(*endptr))) endptr++;
+     while (isdigit((unsigned char)(*endptr)))
+       n = n * 10 + (int)(*endptr++ - '0');
+     if (toupper(*endptr) == 'K')
+       {
+       n *= 1024;
+       endptr++;
+       }
+     else if (toupper(*endptr) == 'M')
+       {
+       n *= 1024*1024;
+       endptr++;
+       }
      if (*endptr != 0)
        {
        if (longop)
          {
          char *equals = strchr(op->long_name, '=');
          int nlen = (equals == NULL)? (int)strlen(op->long_name) :
-           equals - op->long_name;
+           (int)(equals - op->long_name);
          fprintf(stderr, "pcregrep: Malformed number \"%s\" after --%.*s\n",
            option_data, nlen, op->long_name);
          }
        else
          fprintf(stderr, "pcregrep: Malformed number \"%s\" after -%c\n",
            option_data, op->one_char);
-       exit(usage(2));
+       pcregrep_exit(usage(2));
        }
-     *((int *)op->dataptr) = n;
+     if (op->type == OP_LONGNUMBER)
+         *((unsigned long int *)op->dataptr) = n;
+     else
+         *((int *)op->dataptr) = n;
      }
    }
-Line 1743 
 if (both_context > 0)
+Line 2699 
 if (both_context > 0)
    if (before_context == 0) before_context = both_context;
    }
+ /* Only one of --only-matching, --file-offsets, or --line-offsets is permitted.
+ However, the latter two set only_matching. */
+ if ((only_matching >= 0 && (file_offsets || line_offsets)) ||
+     (file_offsets && line_offsets))
+   {
+   fprintf(stderr, "pcregrep: Cannot mix --only-matching, --file-offsets "
+     "and/or --line-offsets\n");
+   pcregrep_exit(usage(2));
+   }
+ if (file_offsets || line_offsets) only_matching = 0;
  /* If a locale has not been provided as an option, see if the LC_CTYPE or
  LC_ALL environment variable is set, and if so, use it. */
-Line 1814 
 else if (strcmp(newline, "any") == 0 ||
+Line 2783 
 else if (strcmp(newline, "any") == 0 ||
    pcre_options |= PCRE_NEWLINE_ANY;
    endlinetype = EL_ANY;
    }
+ else if (strcmp(newline, "anycrlf") == 0 || strcmp(newline, "ANYCRLF") == 0)
+   {
+   pcre_options |= PCRE_NEWLINE_ANYCRLF;
+   endlinetype = EL_ANYCRLF;
+   }
  else
    {
    fprintf(stderr, "pcregrep: Invalid newline specifier \"%s\"\n", newline);
-Line 1860 
 if (jfriedl_XT != 0 || jfriedl_XR != 0)
+Line 2834 
 if (jfriedl_XT != 0 || jfriedl_XR != 0)
    }
  #endif
- /* Get memory to store the pattern and hints lists. */
+ /* Get memory for the main buffer. */
- pattern_list = (pcre **)malloc(MAX_PATTERN_COUNT * sizeof(pcre *));
+ bufsize = 3*bufthird;
- hints_list = (pcre_extra **)malloc(MAX_PATTERN_COUNT * sizeof(pcre_extra *));
+ main_buffer = (char *)malloc(bufsize);
- if (pattern_list == NULL || hints_list == NULL)
+ if (main_buffer == NULL)
    {
    fprintf(stderr, "pcregrep: malloc failed\n");
    goto EXIT2;
    }
- /* If no patterns were provided by -e, and there is no file provided by -f,
+ /* If no patterns were provided by -e, and there are no files provided by -f,
  the first argument is the one and only pattern, and it must exist. */
- if (cmd_pattern_count == 0 && pattern_filename == NULL)
+ if (patterns == NULL && pattern_files == NULL)
    {
    if (i >= argc) return usage(2);
-   patterns[cmd_pattern_count++] = argv[i++];
+   patterns = patterns_last = add_pattern(argv[i++], NULL);
+   if (patterns == NULL) goto EXIT2;
    }
  /* Compile the patterns that were provided on the command line, either by
- multiple uses of -e or as a single unkeyed pattern. */
+ multiple uses of -e or as a single unkeyed pattern. We cannot do this until
+ after all the command-line options are read so that we know which PCRE options
+ to use. When -F is used, compile_pattern() may add another block into the
+ chain, so we must not access the next pointer till after the compile. */
- for (j = 0; j < cmd_pattern_count; j++)
+ for (j = 1, cp = patterns; cp != NULL; j++, cp = cp->next)
    {
-   if (!compile_pattern(patterns[j], pcre_options, NULL,
+   if (!compile_pattern(cp, pcre_options, process_options, FALSE, "command-line",
-        (j == 0 && cmd_pattern_count == 1)? 0 : j + 1))
+        (j == 1 && patterns->next == NULL)? 0 : j))
      goto EXIT2;
    }
- /* Compile the regular expressions that are provided in a file. */
+ /* Read and compile the regular expressions that are provided in files. */
- if (pattern_filename != NULL)
+ for (fn = pattern_files; fn != NULL; fn = fn->next)
    {
-   int linenumber = 0;
+   if (!read_pattern_file(fn->name, &patterns, &patterns_last, process_options))
-   FILE *f;
+     goto EXIT2;
-   char *filename;
+   }
-   char buffer[MBUFTHIRD];
+ /* Study the regular expressions, as we will be running them many times. Unless
+ JIT has been explicitly disabled, arrange a stack for it to use. */
-   if (strcmp(pattern_filename, "-") == 0)
+ #ifdef SUPPORT_PCREGREP_JIT
+ if ((study_options & PCRE_STUDY_JIT_COMPILE) != 0)
+   jit_stack = pcre_jit_stack_alloc(32*1024, 1024*1024);
+ #endif
+ for (j = 1, cp = patterns; cp != NULL; j++, cp = cp->next)
+   {
+   cp->hint = pcre_study(cp->compiled, study_options, &error);
+   if (error != NULL)
      {
-     f = stdin;
+     char s[16];
-     filename = stdin_name;
+     if (patterns->next == NULL) s[0] = 0; else sprintf(s, " number %d", j);
+     fprintf(stderr, "pcregrep: Error while studying regex%s: %s\n", s, error);
+     goto EXIT2;
      }
-   else
+ #ifdef SUPPORT_PCREGREP_JIT
+   if (jit_stack != NULL && cp->hint != NULL)
+     pcre_assign_jit_stack(cp->hint, NULL, jit_stack);
+ #endif
+   }
+ /* If --match-limit or --recursion-limit was set, put the value(s) into the
+ pcre_extra block for each pattern. */
+ if (match_limit > 0 || match_limit_recursion > 0)
+   {
+   for (cp = patterns; cp != NULL; cp = cp->next)
      {
-     f = fopen(pattern_filename, "r");
+     if (cp->hint == NULL)
-     if (f == NULL)
        {
-       fprintf(stderr, "pcregrep: Failed to open %s: %s\n", pattern_filename,
+       cp->hint = (pcre_extra *)malloc(sizeof(pcre_extra));
-         strerror(errno));
+       if (cp->hint == NULL)
-       goto EXIT2;
+         {
+         fprintf(stderr, "pcregrep: malloc failed\n");
+         pcregrep_exit(2);
+         }
+       }
+     if (match_limit > 0)
+       {
+       cp->hint->flags |= PCRE_EXTRA_MATCH_LIMIT;
+       cp->hint->match_limit = match_limit;
+       }
+     if (match_limit_recursion > 0)
+       {
+       cp->hint->flags |= PCRE_EXTRA_MATCH_LIMIT_RECURSION;
+       cp->hint->match_limit_recursion = match_limit_recursion;
        }
-     filename = pattern_filename;
-     }
-   while (fgets(buffer, MBUFTHIRD, f) != NULL)
-     {
-     char *s = buffer + (int)strlen(buffer);
-     while (s > buffer && isspace((unsigned char)(s[-1]))) s--;
-     *s = 0;
-     linenumber++;
-     if (buffer[0] == 0) continue;   /* Skip blank lines */
-     if (!compile_pattern(buffer, pcre_options, filename, linenumber))
-       goto EXIT2;
      }
-   if (f != stdin) fclose(f);
    }
- /* Study the regular expressions, as we will be running them many times */
+ /* If there are include or exclude patterns read from the command line, compile
+ them. -F, -w, and -x do not apply, so the third argument of compile_pattern is
+. */
- for (j = 0; j < pattern_count; j++)
+ for (j = 0; j < 4; j++)
    {
-   hints_list[j] = pcre_study(pattern_list[j], 0, &error);
+   int k;
-   if (error != NULL)
+   for (k = 1, cp = *(incexlist[j]); cp != NULL; k++, cp = cp->next)
      {
-     char s[16];
+     if (!compile_pattern(cp, pcre_options, 0, FALSE, incexname[j],
-     if (pattern_count == 1) s[0] = 0; else sprintf(s, " number %d", j);
+          (k == 1 && cp->next == NULL)? 0 : k))
-     fprintf(stderr, "pcregrep: Error while studying regex%s: %s\n", s, error);
+       goto EXIT2;
-     goto EXIT2;
      }
    }
- /* If there are include or exclude patterns, compile them. */
+ /* Read and compile include/exclude patterns from files. */
- if (exclude_pattern != NULL)
+ for (fn = include_from; fn != NULL; fn = fn->next)
    {
-   exclude_compiled = pcre_compile(exclude_pattern, 0, &error, &errptr,
+   if (!read_pattern_file(fn->name, &include_patterns, &include_patterns_last, 0))
-     pcretables);
-   if (exclude_compiled == NULL)
-     {
-     fprintf(stderr, "pcregrep: Error in 'exclude' regex at offset %d: %s\n",
-       errptr, error);
      goto EXIT2;
-     }
    }
- if (include_pattern != NULL)
+ for (fn = exclude_from; fn != NULL; fn = fn->next)
    {
-   include_compiled = pcre_compile(include_pattern, 0, &error, &errptr,
+   if (!read_pattern_file(fn->name, &exclude_patterns, &exclude_patterns_last, 0))
-     pcretables);
-   if (include_compiled == NULL)
-     {
-     fprintf(stderr, "pcregrep: Error in 'include' regex at offset %d: %s\n",
-       errptr, error);
      goto EXIT2;
-     }
    }
- /* If there are no further arguments, do the business on stdin and exit. */
+ /* If there are no files that contain lists of files to search, and there are
+ no file arguments, search stdin, and then exit. */
- if (i >= argc)
+ if (file_lists == NULL && i >= argc)
    {
-   rc = pcregrep(stdin, (filenames > FN_DEFAULT)? stdin_name : NULL);
+   rc = pcregrep(stdin, FR_PLAIN, stdin_name,
+     (filenames > FN_DEFAULT)? stdin_name : NULL);
    goto EXIT;
    }
- /* Otherwise, work through the remaining arguments as files or directories.
+ /* If any files that contains a list of files to search have been specified,
- Pass in the fact that there is only one argument at top level - this suppresses
+ read them line by line and search the given files. */
- the file name if the argument is not a directory and filenames are not
- otherwise forced. */
- only_one_at_top = i == argc - 1;   /* Catch initial value of i */
+ for (fn = file_lists; fn != NULL; fn = fn->next)
+   {
+   char buffer[PATBUFSIZE];
+   FILE *fl;
+   if (strcmp(fn->name, "-") == 0) fl = stdin; else
+     {
+     fl = fopen(fn->name, "rb");
+     if (fl == NULL)
+       {
+       fprintf(stderr, "pcregrep: Failed to open %s: %s\n", fn->name,
+         strerror(errno));
+       goto EXIT2;
+       }
+     }
+   while (fgets(buffer, PATBUFSIZE, fl) != NULL)
+     {
+     int frc;
+     char *end = buffer + (int)strlen(buffer);
+     while (end > buffer && isspace(end[-1])) end--;
+     *end = 0;
+     if (*buffer != 0)
+       {
+       frc = grep_or_recurse(buffer, dee_action == dee_RECURSE, FALSE);
+       if (frc > 1) rc = frc;
+         else if (frc == 0 && rc == 1) rc = 0;
+       }
+     }
+   if (fl != stdin) fclose(fl);
+   }
+ /* After handling file-list, work through remaining arguments. Pass in the fact
+ that there is only one argument at top level - this suppresses the file name if
+ the argument is not a directory and filenames are not otherwise forced. */
+ only_one_at_top = i == argc - 1 && file_lists == NULL;
  for (; i < argc; i++)
    {
-Line 1994 
 for (; i < argc; i++)
+Line 3016 
 for (; i < argc; i++)
    }
  EXIT:
- if (pattern_list != NULL)
+ #ifdef SUPPORT_PCREGREP_JIT
-   {
+ if (jit_stack != NULL) pcre_jit_stack_free(jit_stack);
-   for (i = 0; i < pattern_count; i++) free(pattern_list[i]);
+ #endif
-   free(pattern_list);
-   }
+ if (main_buffer != NULL) free(main_buffer);
- if (hints_list != NULL)
-   {
+ free_pattern_chain(patterns);
-   for (i = 0; i < pattern_count; i++) free(hints_list[i]);
+ free_pattern_chain(include_patterns);
-   free(hints_list);
+ free_pattern_chain(include_dir_patterns);
-   }
+ free_pattern_chain(exclude_patterns);
- return rc;
+ free_pattern_chain(exclude_dir_patterns);
+ free_file_chain(exclude_from);
+ free_file_chain(include_from);
+ free_file_chain(pattern_files);
+ free_file_chain(file_lists);
+ pcregrep_exit(rc);
  EXIT2:
  rc = 2;

 Legend:



Removed from v.137
 


changed lines


 
Added in v.1004
 Legend:



Removed from v.137
 


changed lines


 
Added in v.1004
-Removed from v.137
+Added in v.1004

	ViewVC Help
Powered by ViewVC 1.1.5