/*************************************************

 *               pcregrep program                 *

 *************************************************/

 /* This is a grep program that uses the PCRE regular expression library to do

 its pattern matching. On a Unix or Win32 system it can recurse into

 directories.

            Copyright (c) 1997-2009 University of Cambridge

 -----------------------------------------------------------------------------

 Redistribution and use in source and binary forms, with or without

 modification, are permitted provided that the following conditions are met:

     * Redistributions of source code must retain the above copyright notice,

       this list of conditions and the following disclaimer.

     * Redistributions in binary form must reproduce the above copyright

       notice, this list of conditions and the following disclaimer in the

       documentation and/or other materials provided with the distribution.

     * Neither the name of the University of Cambridge nor the names of its

       contributors may be used to endorse or promote products derived from

       this software without specific prior written permission.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 POSSIBILITY OF SUCH DAMAGE.

 -----------------------------------------------------------------------------

 */

 #ifdef HAVE_CONFIG_H

 #include "config.h"

 #endif

 #include <ctype.h>

 #include <locale.h>

 #include <stdio.h>

 #include <string.h>

 #include <stdlib.h>

 #include <errno.h>

 #include <sys/types.h>

 #include <sys/stat.h>

 #ifdef HAVE_UNISTD_H

 #include <unistd.h>

 #endif

 #ifdef SUPPORT_LIBZ

 #include <zlib.h>

 #endif

 #ifdef SUPPORT_LIBBZ2

 #include <bzlib.h>

 #endif

 #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

 #else

 #define MBUFTHIRD 8192

 #endif

 /* 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 };

 /* File reading styles */

 enum { FR_PLAIN, FR_LIBZ, FR_LIBBZ2 };

 /* Actions for the -d and -D options */

 enum { dee_READ, dee_SKIP, dee_RECURSE };

 enum { DEE_READ, DEE_SKIP };

 /* Actions for special processing options (flag bits) */

 #define PO_WORD_MATCH     0x0001

 #define PO_LINE_MATCH     0x0002

 #define PO_FIXED_STRINGS  0x0004

 /* Line ending types */

 enum { EL_LF, EL_CR, EL_CRLF, EL_ANY, EL_ANYCRLF };

 /*************************************************

 *               Global variables                 *

 *************************************************/

 /* Jeffrey Friedl has some debugging requirements that are not part of the

 regular code. */

 #ifdef JFRIEDL_DEBUG

 static int S_arg = -1;

 static unsigned int jfriedl_XR = 0; /* repeat regex attempt this many times */

 static unsigned int jfriedl_XT = 0; /* replicate text this many times */

 static const char *jfriedl_prefix = "";

 static const char *jfriedl_postfix = "";

 #endif

 static int  endlinetype;

 static char *colour_string = (char *)"1;31";

 static char *colour_option = NULL;

 static char *dee_option = NULL;

 static char *DEE_option = 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 char *include_dir_pattern = NULL;

 static char *exclude_dir_pattern = NULL;

 static pcre *include_compiled = NULL;

 static pcre *exclude_compiled = NULL;

 static pcre *include_dir_compiled = NULL;

 static pcre *exclude_dir_compiled = NULL;

 static int after_context = 0;

 static int before_context = 0;

 static int both_context = 0;

 static int dee_action = dee_READ;

 static int DEE_action = DEE_READ;

 static int error_count = 0;

 static int filenames = FN_DEFAULT;

 static int process_options = 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_offsets = FALSE;

 static BOOL multiline = FALSE;

 static BOOL number = FALSE;

 static BOOL only_matching = FALSE;

 static BOOL quiet = FALSE;

 static BOOL silent = FALSE;

 static BOOL utf8 = FALSE;

 /* Structure for options and list of them */

 enum { OP_NODATA, OP_STRING, OP_OP_STRING, OP_NUMBER, OP_OP_NUMBER,

        OP_PATLIST };

 typedef struct option_item {

   int type;

   int one_char;

   void *dataptr;

   const char *long_name;

   const char *help_text;

 } 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_EXCLUDE      (-2)

 #define N_EXCLUDE_DIR  (-3)

 #define N_HELP         (-4)

 #define N_INCLUDE      (-5)

 #define N_INCLUDE_DIR  (-6)

 #define N_LABEL        (-7)

 #define N_LOCALE       (-8)

 #define N_NULL         (-9)

 #define N_LOFFSETS     (-10)

 #define N_FOFFSETS     (-11)

 static option_item optionlist[] = {

   { OP_NODATA,    N_NULL,   NULL,              "",              "  terminate options" },

   { 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,    'B',      &before_context,   "before-context=number", "set number of prior context lines" },

   { OP_OP_STRING, N_COLOUR, &colour_option,    "color=option",  "matched text color option" },

   { OP_NUMBER,    'C',      &both_context,     "context=number", "set number of context lines, before & after" },

   { OP_NODATA,    'c',      NULL,              "count",         "print only a count of matching lines per FILE" },

   { OP_OP_STRING, N_COLOUR, &colour_option,    "colour=option", "matched text colour option" },

   { OP_STRING,    'D',      &DEE_option,       "devices=action","how to handle devices, FIFOs, and sockets" },

   { OP_STRING,    'd',      &dee_option,       "directories=action", "how to handle directories" },

   { OP_PATLIST,   'e',      NULL,              "regex(p)",      "specify pattern (may be used more than once)" },

   { OP_NODATA,    'F',      NULL,              "fixed_strings", "patterns are sets of newline-separated strings" },

   { OP_STRING,    'f',      &pattern_filename, "file=path",     "read patterns from file" },

   { OP_NODATA,    N_FOFFSETS, NULL,            "file-offsets",  "output file offsets, not text" },

   { OP_NODATA,    'H',      NULL,              "with-filename", "force the prefixing filename on output" },

   { OP_NODATA,    'h',      NULL,              "no-filename",   "suppress the prefixing filename on output" },

   { OP_NODATA,    'i',      NULL,              "ignore-case",   "ignore case distinctions" },

   { 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_LOFFSETS, NULL,            "line-offsets",  "output line numbers and offsets, not text" },

   { OP_STRING,    N_LOCALE, &locale,           "locale=locale", "use the named locale" },

   { 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_NODATA,    'o',      NULL,              "only-matching", "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_STRING,    N_EXCLUDE,&exclude_pattern,  "exclude=pattern","exclude matching files when recursing" },

   { OP_STRING,    N_INCLUDE,&include_pattern,  "include=pattern","include matching files when recursing" },

   { OP_STRING,    N_EXCLUDE_DIR,&exclude_dir_pattern, "exclude_dir=pattern","exclude matching directories when recursing" },

   { OP_STRING,    N_INCLUDE_DIR,&include_dir_pattern, "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

   { OP_NODATA,    's',      NULL,              "no-messages",   "suppress error messages" },

   { OP_NODATA,    'u',      NULL,              "utf-8",         "use UTF-8 mode" },

   { OP_NODATA,    'V',      NULL,              "version",       "print version information and exit" },

   { OP_NODATA,    'v',      NULL,              "invert-match",  "select non-matching lines" },

   { OP_NODATA,    'w',      NULL,              "word-regex(p)", "force patterns to match only as words"  },

   { OP_NODATA,    'x',      NULL,              "line-regex(p)", "force patterns to match only whole lines" },

   { OP_NODATA,    0,        NULL,               NULL,            NULL }

 };

 /* 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. */

 static const char *prefix[] = {

   "", "\\b", "^(?:", "^(?:", "\\Q", "\\b\\Q", "^(?:\\Q", "^(?:\\Q" };

 static const char *suffix[] = {

   "", "\\b", ")$",   ")$",   "\\E", "\\E\\b", "\\E)$",   "\\E)$" };

 /* UTF-8 tables - used only when the newline setting is "any". */

 const int utf8_table3[] = { 0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};

 const char utf8_table4[] = {

   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

   2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,

   3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };

 /*************************************************

 *            OS-specific functions               *

 *************************************************/

 /* These functions are defined so that they can be made system specific,

 although at present the only ones are for Unix, Win32, and for "no support". */

 /************* Directory scanning in Unix ***********/

 #if defined HAVE_SYS_STAT_H && defined HAVE_DIRENT_H && defined HAVE_SYS_TYPES_H

 #include <sys/types.h>

 #include <sys/stat.h>

 #include <dirent.h>

 typedef DIR directory_type;

 static int

 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;

 }

 static directory_type *

 opendirectory(char *filename)

 {

 return opendir(filename);

 }

 static char *

 readdirectory(directory_type *dir)

 {

 for (;;)

   {

   struct dirent *dent = readdir(dir);

   if (dent == NULL) return NULL;

   if (strcmp(dent->d_name, ".") != 0 && strcmp(dent->d_name, "..") != 0)

     return dent->d_name;

   }

 /* Control never reaches here */

 }

 static void

 closedirectory(directory_type *dir)

 {

 closedir(dir);

 }

 /************* Test for regular file in Unix **********/

 static int

 isregfile(char *filename)

 {

 struct stat statbuf;

 if (stat(filename, &statbuf) < 0)

   return 1;        /* In the expectation that opening as a file will fail */

 return (statbuf.st_mode & S_IFMT) == S_IFREG;

 }

 /************* Test stdout for being a terminal in Unix **********/

 static BOOL

 is_stdout_tty(void)

 {

 return isatty(fileno(stdout));

 }

 /************* 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. David Byron added a patch that moved the #include of

 <windows.h> to before the INVALID_FILE_ATTRIBUTES definition rather than after.

 */

 #elif HAVE_WINDOWS_H

 #ifndef STRICT

 # define STRICT

 #endif

 #ifndef WIN32_LEAN_AND_MEAN

 # define WIN32_LEAN_AND_MEAN

 #endif

 #include <windows.h>

 #ifndef INVALID_FILE_ATTRIBUTES

 #define INVALID_FILE_ATTRIBUTES 0xFFFFFFFF

 #endif

 typedef struct directory_type

 {

 HANDLE handle;

 BOOL first;

 WIN32_FIND_DATA data;

 } directory_type;

 int

 isdirectory(char *filename)

 {

 DWORD attr = GetFileAttributes(filename);

 if (attr == INVALID_FILE_ATTRIBUTES)

   return 0;

 return ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) ? '/' : 0;

 }

 directory_type *

 opendirectory(char *filename)

 {

 size_t len;

 char *pattern;

 directory_type *dir;

 DWORD err;

 len = strlen(filename);

 pattern = (char *) malloc(len + 3);

 dir = (directory_type *) malloc(sizeof(*dir));

 if ((pattern == NULL) || (dir == NULL))

   {

   fprintf(stderr, "pcregrep: malloc failed\n");

   exit(2);

   }

 memcpy(pattern, filename, len);

 memcpy(&(pattern[len]), "\\*", 3);

 dir->handle = FindFirstFile(pattern, &(dir->data));

 if (dir->handle != INVALID_HANDLE_VALUE)

   {

   free(pattern);

   dir->first = TRUE;

   return dir;

   }

 err = GetLastError();

 free(pattern);

 free(dir);

 errno = (err == ERROR_ACCESS_DENIED) ? EACCES : ENOENT;

 return NULL;

 }

 char *

 readdirectory(directory_type *dir)

 {

 for (;;)

   {

   if (!dir->first)

     {

     if (!FindNextFile(dir->handle, &(dir->data)))

       return NULL;

     }

   else

     {

     dir->first = FALSE;

     }

   if (strcmp(dir->data.cFileName, ".") != 0 && strcmp(dir->data.cFileName, "..") != 0)

     return dir->data.cFileName;

   }

 #ifndef _MSC_VER

 return NULL;   /* Keep compiler happy; never executed */

 #endif

 }

 void

 closedirectory(directory_type *dir)

 {

 FindClose(dir->handle);

 free(dir);

 }

 /************* Test for regular file in Win32 **********/

 /* I don't know how to do this, or if it can be done; assume all paths are

 regular if they are not directories. */

 int isregfile(char *filename)

 {

 return !isdirectory(filename);

 }

 /************* Test stdout for being a terminal in Win32 **********/

 /* I don't know how to do this; assume never */

 static BOOL

 is_stdout_tty(void)

 {

 return FALSE;

 }

 /************* Directory scanning when we can't do it ***********/

 /* The type is void, and apart from isdirectory(), the functions do nothing. */

 #else

 typedef void directory_type;

 int isdirectory(char *filename) { return 0; }

 directory_type * opendirectory(char *filename) { return (directory_type*)0;}

 char *readdirectory(directory_type *dir) { return (char*)0;}

 void closedirectory(directory_type *dir) {}

 /************* Test for regular when we can't do it **********/

 /* Assume all files are regular. */

 int isregfile(char *filename) { return 1; }

 /************* Test stdout for being a terminal when we can't do it **********/

 static BOOL

 is_stdout_tty(void)

 {

 return FALSE;

 }

 #endif

 #ifndef HAVE_STRERROR

 /*************************************************

 *     Provide strerror() for non-ANSI libraries  *

 *************************************************/

 /* Some old-fashioned systems still around (e.g. SunOS4) don't have strerror()

 in their libraries, but can provide the same facility by this simple

 alternative function. */

 extern int   sys_nerr;

 extern char *sys_errlist[];

 char *

 strerror(int n)

 {

 if (n < 0 || n >= sys_nerr) return "unknown error number";

 return sys_errlist[n];

 }

 #endif /* HAVE_STRERROR */

 /*************************************************

 *             Find end of line                   *

 *************************************************/

 /* The length of the endline sequence that is found is set via lenptr. This may

 be zero at the very end of the file if there is no line-ending sequence there.

 Arguments:

   p         current position in line

   endptr    end of available data

   lenptr    where to put the length of the eol sequence

 Returns:    pointer to the last byte of the line

 */

 static char *

 end_of_line(char *p, char *endptr, int *lenptr)

 {

 switch(endlinetype)

   {

   default:      /* Just in case */

   case EL_LF:

   while (p < endptr && *p != '\n') p++;

   if (p < endptr)

     {

     *lenptr = 1;

     return p + 1;

     }

   *lenptr = 0;

   return endptr;

   case EL_CR:

   while (p < endptr && *p != '\r') p++;

   if (p < endptr)

     {

     *lenptr = 1;

     return p + 1;

     }

   *lenptr = 0;

   return endptr;

   case EL_CRLF:

   for (;;)

     {

     while (p < endptr && *p != '\r') p++;

     if (++p >= endptr)

       {

       *lenptr = 0;

       return endptr;

       }

     if (*p == '\n')

       {

       *lenptr = 2;

       return p + 1;

       }

     }

   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)

     {

     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 */

       case 0x0b:    /* VT */

       case 0x0c:    /* FF */

       *lenptr = 1;

       return p;

       case 0x0d:    /* CR */

       if (p < endptr && *p == 0x0a)

         {

         *lenptr = 2;

         p++;

         }

       else *lenptr = 1;

       return p;

       case 0x85:    /* NEL */

       *lenptr = utf8? 2 : 1;

       return p;

       case 0x2028:  /* LS */

       case 0x2029:  /* PS */

       *lenptr = 3;

       return p;

       default:

       break;

       }

     }   /* End of loop for ANY case */

   *lenptr = 0;  /* Must have hit the end */

   return endptr;

   }     /* End of overall switch */

 }

 /*************************************************

 *         Find start of previous line            *

 *************************************************/

 /* This is called when looking back for before lines to print.

 Arguments:

   p         start of the subsequent line

   startptr  start of available data

 Returns:    pointer to the start of the previous line

 */

 static char *

 previous_line(char *p, char *startptr)

 {

 switch(endlinetype)

   {

   default:      /* Just in case */

   case EL_LF:

   p--;

   while (p > startptr && p[-1] != '\n') p--;

   return p;

   case EL_CR:

   p--;

   while (p > startptr && p[-1] != '\n') p--;

   return p;

   case EL_CRLF:

   for (;;)

     {

     p -= 2;

     while (p > startptr && p[-1] != '\n') p--;

     if (p <= startptr + 1 || p[-2] == '\r') return p;

     }

   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--;

   while (p > startptr)

     {

     register int c;

     char *pp = p - 1;

     if (utf8)

       {

       int extra = 0;

       while ((*pp & 0xc0) == 0x80) pp--;

       c = *((unsigned char *)pp);

       if (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 |= (pp[gcii] & 0x3f) << gcss;

           }

         }

       }

     else c = *((unsigned char *)pp);

     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 */

       case 0x0c:    /* FF */

       case 0x0d:    /* CR */

       case 0x85:    /* NEL */

       case 0x2028:  /* LS */

       case 0x2029:  /* PS */

       return p;

       default:

       break;

       }

     p = pp;  /* Back one character */

     }        /* End of loop for ANY case */

   return startptr;  /* Hit start of data */

   }     /* End of overall switch */

 }

 /*************************************************

 *       Print the previous "after" lines         *

 *************************************************/

 /* This is called if we are about to lose said lines because of buffer filling,

 and at the end of the file. The data in the line is written using fwrite() so

 that a binary zero does not terminate it.

 Arguments:

   lastmatchnumber   the number of the last matching line, plus one

   lastmatchrestart  where we restarted after the last match

   endptr            end of available data

   printname         filename for printing

 Returns:            nothing

 */

 static void do_after_lines(int lastmatchnumber, char *lastmatchrestart,

   char *endptr, char *printname)

 {

 if (after_context > 0 && lastmatchnumber > 0)

   {

   int count = 0;

   while (lastmatchrestart < endptr && count++ < after_context)

     {

     int ellength;

     char *pp = lastmatchrestart;

     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);

     lastmatchrestart = pp;

     }

   hyphenpending = TRUE;

   }

 }

 /*************************************************

 *   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

   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 *offsets, int *mrc)

 {

 int i;

 for (i = 0; i < pattern_count; i++)

   {

   *mrc = pcre_exec(pattern_list[i], hints_list[i], matchptr, length, 0,

     PCRE_NOTEMPTY, offsets, OFFSET_SIZE);

   if (*mrc >= 0) return TRUE;

   if (*mrc == PCRE_ERROR_NOMATCH) continue;

   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 text:\n");

   fwrite(matchptr, 1, length, 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);

     }

   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

 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:

   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

   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

                1 otherwise (no matches)

                2 if there is a read error on a .bz2 file

 */

 static int

 pcregrep(void *handle, int frtype, char *printname)

 {

 int rc = 1;

 int linenumber = 1;

 int lastmatchnumber = 0;

 int count = 0;

 int filepos = 0;

 int offsets[OFFSET_SIZE];

 char *lastmatchrestart = NULL;

 char buffer[3*MBUFTHIRD];

 char *ptr = buffer;

 char *endptr;

 size_t bufflength;

 BOOL endhyphenpending = FALSE;

 FILE *in = NULL;                    /* Ensure initialized */

 #ifdef SUPPORT_LIBZ

 gzFile ingz = NULL;

 #endif

 #ifdef SUPPORT_LIBBZ2

 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, buffer, 3*MBUFTHIRD);

   }

 else

 #endif

 #ifdef SUPPORT_LIBBZ2

 if (frtype == FR_LIBBZ2)

   {

   inbz2 = (BZFILE *)handle;

   bufflength = BZ2_bzread(inbz2, buffer, 3*MBUFTHIRD);

   if ((int)bufflength < 0) return 2;   /* Gotcha: bufflength is size_t; */