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

 *               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-2012 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 OFFSET_SIZE 99

 #if BUFSIZ > 8192

 #define MAXPATLEN BUFSIZ

 #else

 #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_MATCH_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 };

 /* 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)) {}

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

 *               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 *locale = NULL;

 static char *main_buffer = NULL;

 static char *newline = NULL;

 static char *om_separator = (char *)"";

 static char *stdin_name = (char *)"(standard input)";

 static const unsigned char *pcretables = 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 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 omit_zero_count = FALSE;

 static BOOL resource_error = FALSE;

 static BOOL quiet = FALSE;

 static BOOL show_only_matching = FALSE;

 static BOOL silent = FALSE;

 static BOOL utf8 = FALSE;

 /* Structure for list of --only-matching capturing numbers. */

 typedef struct omstr {

   struct omstr *next;

   int groupnum;

 } omstr;

 static omstr *only_matching = NULL;

 static omstr *only_matching_last = NULL;

 /* Structure for holding the two variables that describe a number chain. */

 typedef struct omdatastr {

   omstr **anchor;

   omstr **lastptr;

 } omdatastr;

 static omdatastr only_matching_data = { &only_matching, &only_matching_last };

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

        OP_OP_NUMBER, OP_OP_NUMBERS, OP_PATLIST, OP_FILELIST, OP_BINFILES };

 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)

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

 #define N_OM_SEPARATOR (-21)

 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_NODATA,     'a',      NULL,              "text",          "treat binary files as text" },

   { OP_NUMBER,     'B',      &before_context,   "before-context=number", "set number of prior context lines" },

   { OP_BINFILES,   N_BINARY_FILES, NULL,        "binary-files=word", "set treatment of binary files" },

   { OP_NUMBER,     N_BUFSIZE,&bufthird,         "buffer-size=number", "set processing buffer size parameter" },

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

   { OP_OP_STRING,  N_COLOUR, &colour_option,    "colour=option", "matched text colour 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_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',      &match_patdata,    "regex(p)=pattern", "specify pattern (may be used more than once)" },

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

   { OP_FILELIST,   'f',      &pattern_files_data, "file=path",   "read patterns from file" },

   { OP_FILELIST,   N_FILE_LIST, &file_lists_data, "file-list=path","read files to search 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,              "",              "treat binary files as not matching (ignore)" },

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

 #ifdef SUPPORT_PCREGREP_JIT

   { OP_NODATA,     N_NOJIT,  NULL,              "no-jit",        "do not use just-in-time compiler optimization" },

 #else

   { OP_NODATA,     N_NOJIT,  NULL,              "no-jit",        "ignored: this pcregrep does not support JIT" },

 #endif

   { 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_NUMBERS, 'o',      &only_matching_data, "only-matching=n", "show only the part of the line that matched" },

   { OP_STRING,     N_OM_SEPARATOR, &om_separator, "om-separator=text", "set separator for multiple -o output" },

   { 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

   { 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. 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" };

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

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

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

 }

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

 *          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

 */

 static patstr *

 add_pattern(char *s, patstr *after)

 {

 patstr *p = (patstr *)malloc(sizeof(patstr));

 if (p == NULL)

   {

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

   pcregrep_exit(2);

   }

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

   }

 }

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

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

 #define FILESEP '/'

 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;

 }

 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 for a terminal in Unix **********/

 static BOOL

 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. 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 defined HAVE_WINDOWS_H && 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;

 #define FILESEP '/'

 int

 isdirectory(char *filename)

 {

 DWORD attr = GetFileAttributes(filename);

 if (attr == INVALID_FILE_ATTRIBUTES)

   return 0;

 return (attr & FILE_ATTRIBUTE_DIRECTORY) != 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");

   pcregrep_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 for a terminal in Win32 **********/

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

 static BOOL

 is_stdout_tty(void)

 {

 return FALSE;

 }

 static BOOL

 is_file_tty(FILE *f)

 {

 return FALSE;

 }

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

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

 #else

 #define FILESEP 0

 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 for a terminal when we can't do it **********/

 static BOOL

 is_stdout_tty(void)

 {

 return FALSE;

 }

 static BOOL

 is_file_tty(FILE *f)

 {

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

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

 *                Usage function                  *

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

 static int

 usage(int rc)

 {

 option_item *op;

 fprintf(stderr, "Usage: pcregrep [-");

 for (op = optionlist; op->one_char != 0; op++)

   {

   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 and the long "

   "options.\n");

 return rc;

 }

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

 *                Help function                   *

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

 static void

 help(void)

 {

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

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

   /* Two options were accidentally implemented and documented with underscores

   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("\nNumbers may be followed by K or M, e.g. --buffer-size=100K.\n");

 printf("The default value for --buffer-size is %d.\n", PCREGREP_BUFSIZE);

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

 }

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

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

 }

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

 *         Decode integer argument value          *

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

 /* Integer arguments can be followed by K or M. Avoid the use of strtoul()

 because SunOS4 doesn't have it. This is used only for unpicking arguments, so

 just keep it simple.

 Arguments:

   option_data   the option data string

   op            the option item (for error messages)

   longop        TRUE if option given in long form

 Returns:        a long integer

 */

 static long int

 decode_number(char *option_data, option_item *op, BOOL longop)

 {

 unsigned long int n = 0;

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

   {

   if (longop)

     {

     char *equals = strchr(op->long_name, '=');

     int nlen = (equals == NULL)? (int)strlen(op->long_name) :