1 /*************************************************

     2 *               pcregrep program                 *

     3 *************************************************/

     4 

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

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

     7 directories.

     8 

     9            Copyright (c) 1997-2008 University of Cambridge

    10 

    11 -----------------------------------------------------------------------------

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

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

    14 

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

    16       this list of conditions and the following disclaimer.

    17 

    18     * Redistributions in binary form must reproduce the above copyright

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

    20       documentation and/or other materials provided with the distribution.

    21 

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

    23       contributors may be used to endorse or promote products derived from

    24       this software without specific prior written permission.

    25 

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

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

    28 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

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

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

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

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

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

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

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

    36 POSSIBILITY OF SUCH DAMAGE.

    37 -----------------------------------------------------------------------------

    38 */

    39 

    40 #ifdef HAVE_CONFIG_H

    41 #include "config.h"

    42 #endif

    43 

    44 #include <ctype.h>

    45 #include <locale.h>

    46 #include <stdio.h>

    47 #include <string.h>

    48 #include <stdlib.h>

    49 #include <errno.h>

    50 

    51 #include <sys/types.h>

    52 #include <sys/stat.h>

    53 

    54 #ifdef HAVE_UNISTD_H

    55 #include <unistd.h>

    56 #endif

    57 

    58 #ifdef SUPPORT_LIBZ

    59 #include <zlib.h>

    60 #endif

    61 

    62 #ifdef SUPPORT_LIBBZ2

    63 #include <bzlib.h>

    64 #endif

    65 

    66 #include "pcre.h"

    67 

    68 #define FALSE 0

    69 #define TRUE 1

    70 

    71 typedef int BOOL;

    72 

    73 #define MAX_PATTERN_COUNT 100

    74 

    75 #if BUFSIZ > 8192

    76 #define MBUFTHIRD BUFSIZ

    77 #else

    78 #define MBUFTHIRD 8192

    79 #endif

    80 

    81 /* Values for the "filenames" variable, which specifies options for file name

    82 output. The order is important; it is assumed that a file name is wanted for

    83 all values greater than FN_DEFAULT. */

    84 

    85 enum { FN_NONE, FN_DEFAULT, FN_ONLY, FN_NOMATCH_ONLY, FN_FORCE };

    86 

    87 /* File reading styles */

    88 

    89 enum { FR_PLAIN, FR_LIBZ, FR_LIBBZ2 };

    90 

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

    92 

    93 enum { dee_READ, dee_SKIP, dee_RECURSE };

    94 enum { DEE_READ, DEE_SKIP };

    95 

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

    97 

    98 #define PO_WORD_MATCH     0x0001

    99 #define PO_LINE_MATCH     0x0002

   100 #define PO_FIXED_STRINGS  0x0004

   101 

   102 /* Line ending types */

   103 

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

   105 

   106 

   107 

   108 /*************************************************

   109 *               Global variables                 *

   110 *************************************************/

   111 

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

   113 regular code. */

   114 

   115 #ifdef JFRIEDL_DEBUG

   116 static int S_arg = -1;

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

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

   119 static const char *jfriedl_prefix = "";

   120 static const char *jfriedl_postfix = "";

   121 #endif

   122 

   123 static int  endlinetype;

   124 

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

   126 static char *colour_option = NULL;

   127 static char *dee_option = NULL;

   128 static char *DEE_option = NULL;

   129 static char *newline = NULL;

   130 static char *pattern_filename = NULL;

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

   132 static char *locale = NULL;

   133 

   134 static const unsigned char *pcretables = NULL;

   135 

   136 static int  pattern_count = 0;

   137 static pcre **pattern_list = NULL;

   138 static pcre_extra **hints_list = NULL;

   139 

   140 static char *include_pattern = NULL;

   141 static char *exclude_pattern = NULL;

   142 static char *include_dir_pattern = NULL;

   143 static char *exclude_dir_pattern = NULL;

   144 

   145 static pcre *include_compiled = NULL;

   146 static pcre *exclude_compiled = NULL;

   147 static pcre *include_dir_compiled = NULL;

   148 static pcre *exclude_dir_compiled = NULL;

   149 

   150 static int after_context = 0;

   151 static int before_context = 0;

   152 static int both_context = 0;

   153 static int dee_action = dee_READ;

   154 static int DEE_action = DEE_READ;

   155 static int error_count = 0;

   156 static int filenames = FN_DEFAULT;

   157 static int process_options = 0;

   158 

   159 static BOOL count_only = FALSE;

   160 static BOOL do_colour = FALSE;

   161 static BOOL file_offsets = FALSE;

   162 static BOOL hyphenpending = FALSE;

   163 static BOOL invert = FALSE;

   164 static BOOL line_offsets = FALSE;

   165 static BOOL multiline = FALSE;

   166 static BOOL number = FALSE;

   167 static BOOL only_matching = FALSE;

   168 static BOOL quiet = FALSE;

   169 static BOOL silent = FALSE;

   170 static BOOL utf8 = FALSE;

   171 

   172 /* Structure for options and list of them */

   173 

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

   175        OP_PATLIST };

   176 

   177 typedef struct option_item {

   178   int type;

   179   int one_char;

   180   void *dataptr;

   181   const char *long_name;

   182   const char *help_text;

   183 } option_item;

   184 

   185 /* Options without a single-letter equivalent get a negative value. This can be

   186 used to identify them. */

   187 

   188 #define N_COLOUR       (-1)

   189 #define N_EXCLUDE      (-2)

   190 #define N_EXCLUDE_DIR  (-3)

   191 #define N_HELP         (-4)

   192 #define N_INCLUDE      (-5)

   193 #define N_INCLUDE_DIR  (-6)

   194 #define N_LABEL        (-7)

   195 #define N_LOCALE       (-8)

   196 #define N_NULL         (-9)

   197 #define N_LOFFSETS     (-10)

   198 #define N_FOFFSETS     (-11)

   199 

   200 static option_item optionlist[] = {

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

   202   { OP_NODATA,    N_HELP,   NULL,              "help",          "display this help and exit" },

   203   { OP_NUMBER,    'A',      &after_context,    "after-context=number", "set number of following context lines" },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   218   { OP_NODATA,    'l',      NULL,              "files-with-matches", "print only FILE names containing matches" },

   219   { OP_NODATA,    'L',      NULL,              "files-without-match","print only FILE names not containing matches" },

   220   { OP_STRING,    N_LABEL,  &stdin_name,       "label=name",    "set name for standard input" },

   221   { OP_NODATA,    N_LOFFSETS, NULL,            "line-offsets",  "output line numbers and offsets, not text" },

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

   223   { OP_NODATA,    'M',      NULL,              "multiline",     "run in multiline mode" },

   224   { OP_STRING,    'N',      &newline,          "newline=type",  "set newline type (CR, LF, CRLF, ANYCRLF or ANY)" },

   225   { OP_NODATA,    'n',      NULL,              "line-number",   "print line number with output lines" },

   226   { OP_NODATA,    'o',      NULL,              "only-matching", "show only the part of the line that matched" },

   227   { OP_NODATA,    'q',      NULL,              "quiet",         "suppress output, just set return code" },

   228   { OP_NODATA,    'r',      NULL,              "recursive",     "recursively scan sub-directories" },

   229   { OP_STRING,    N_EXCLUDE,&exclude_pattern,  "exclude=pattern","exclude matching files when recursing" },

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

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

   232   { OP_STRING,    N_INCLUDE_DIR,&include_dir_pattern, "include_dir=pattern","include matching directories when recursing" },

   233 #ifdef JFRIEDL_DEBUG

   234   { OP_OP_NUMBER, 'S',      &S_arg,            "jeffS",         "replace matched (sub)string with X" },

   235 #endif

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

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

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

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

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

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

   242   { OP_NODATA,    0,        NULL,               NULL,            NULL }

   243 };

   244 

   245 /* Tables for prefixing and suffixing patterns, according to the -w, -x, and -F

   246 options. These set the 1, 2, and 4 bits in process_options, respectively. Note

   247 that the combination of -w and -x has the same effect as -x on its own, so we

   248 can treat them as the same. */

   249 

   250 static const char *prefix[] = {

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

   252 

   253 static const char *suffix[] = {

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

   255 

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

   257 

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

   259 

   260 const char utf8_table4[] = {

   261   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

   262   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

   263   2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,

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

   265 

   266 

   267 

   268 /*************************************************

   269 *            OS-specific functions               *

   270 *************************************************/

   271 

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

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

   274 

   275 

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

   277 

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

   279 #include <sys/types.h>

   280 #include <sys/stat.h>

   281 #include <dirent.h>

   282 

   283 typedef DIR directory_type;

   284 

   285 static int

   286 isdirectory(char *filename)

   287 {

   288 struct stat statbuf;

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

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

   291 return ((statbuf.st_mode & S_IFMT) == S_IFDIR)? '/' : 0;

   292 }

   293 

   294 static directory_type *

   295 opendirectory(char *filename)

   296 {

   297 return opendir(filename);

   298 }

   299 

   300 static char *

   301 readdirectory(directory_type *dir)

   302 {

   303 for (;;)

   304   {

   305   struct dirent *dent = readdir(dir);

   306   if (dent == NULL) return NULL;

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

   308     return dent->d_name;

   309   }

   310 /* Control never reaches here */

   311 }

   312 

   313 static void

   314 closedirectory(directory_type *dir)

   315 {

   316 closedir(dir);

   317 }

   318 

   319 

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

   321 

   322 static int

   323 isregfile(char *filename)

   324 {

   325 struct stat statbuf;

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

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

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

   329 }

   330 

   331 

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

   333 

   334 static BOOL

   335 is_stdout_tty(void)

   336 {

   337 return isatty(fileno(stdout));

   338 }

   339 

   340 

   341 /************* Directory scanning in Win32 ***********/

   342 

   343 /* I (Philip Hazel) have no means of testing this code. It was contributed by

   344 Lionel Fourquaux. David Burgess added a patch to define INVALID_FILE_ATTRIBUTES

   345 when it did not exist. David Byron added a patch that moved the #include of

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

   347 */

   348 

   349 #elif HAVE_WINDOWS_H

   350 

   351 #ifndef STRICT

   352 # define STRICT

   353 #endif

   354 #ifndef WIN32_LEAN_AND_MEAN

   355 # define WIN32_LEAN_AND_MEAN

   356 #endif

   357 

   358 #include <windows.h>

   359 

   360 #ifndef INVALID_FILE_ATTRIBUTES

   361 #define INVALID_FILE_ATTRIBUTES 0xFFFFFFFF

   362 #endif

   363 

   364 typedef struct directory_type

   365 {

   366 HANDLE handle;

   367 BOOL first;

   368 WIN32_FIND_DATA data;

   369 } directory_type;

   370 

   371 int

   372 isdirectory(char *filename)

   373 {

   374 DWORD attr = GetFileAttributes(filename);

   375 if (attr == INVALID_FILE_ATTRIBUTES)

   376   return 0;

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

   378 }

   379 

   380 directory_type *

   381 opendirectory(char *filename)

   382 {

   383 size_t len;

   384 char *pattern;

   385 directory_type *dir;

   386 DWORD err;

   387 len = strlen(filename);

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

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

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

   391   {

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

   393   exit(2);

   394   }

   395 memcpy(pattern, filename, len);

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

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

   398 if (dir->handle != INVALID_HANDLE_VALUE)

   399   {

   400   free(pattern);

   401   dir->first = TRUE;

   402   return dir;

   403   }

   404 err = GetLastError();

   405 free(pattern);

   406 free(dir);

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

   408 return NULL;

   409 }

   410 

   411 char *

   412 readdirectory(directory_type *dir)

   413 {

   414 for (;;)

   415   {

   416   if (!dir->first)

   417     {

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

   419       return NULL;

   420     }

   421   else

   422     {

   423     dir->first = FALSE;

   424     }

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

   426     return dir->data.cFileName;

   427   }

   428 #ifndef _MSC_VER

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

   430 #endif

   431 }

   432 

   433 void

   434 closedirectory(directory_type *dir)

   435 {

   436 FindClose(dir->handle);

   437 free(dir);

   438 }

   439 

   440 

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

   442 

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

   444 regular if they are not directories. */

   445 

   446 int isregfile(char *filename)

   447 {

   448 return !isdirectory(filename);

   449 }

   450 

   451 

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

   453 

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

   455 

   456 static BOOL

   457 is_stdout_tty(void)

   458 {

   459 return FALSE;

   460 }

   461 

   462 

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

   464 

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

   466 

   467 #else

   468 

   469 typedef void directory_type;

   470 

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

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

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

   474 void closedirectory(directory_type *dir) {}

   475 

   476 

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

   478 

   479 /* Assume all files are regular. */

   480 

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

   482 

   483 

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

   485 

   486 static BOOL

   487 is_stdout_tty(void)

   488 {

   489 return FALSE;

   490 }

   491 

   492 

   493 #endif

   494 

   495 

   496 

   497 #ifndef HAVE_STRERROR

   498 /*************************************************

   499 *     Provide strerror() for non-ANSI libraries  *

   500 *************************************************/

   501 

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

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

   504 alternative function. */

   505 

   506 extern int   sys_nerr;

   507 extern char *sys_errlist[];

   508 

   509 char *

   510 strerror(int n)

   511 {

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

   513 return sys_errlist[n];

   514 }

   515 #endif /* HAVE_STRERROR */

   516 

   517 

   518 

   519 /*************************************************

   520 *             Find end of line                   *

   521 *************************************************/

   522 

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

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

   525 

   526 Arguments:

   527   p         current position in line

   528   endptr    end of available data

   529   lenptr    where to put the length of the eol sequence

   530 

   531 Returns:    pointer to the last byte of the line

   532 */

   533 

   534 static char *

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

   536 {

   537 switch(endlinetype)

   538   {

   539   default:      /* Just in case */

   540   case EL_LF:

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

   542   if (p < endptr)

   543     {

   544     *lenptr = 1;

   545     return p + 1;

   546     }

   547   *lenptr = 0;

   548   return endptr;

   549 

   550   case EL_CR:

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

   552   if (p < endptr)

   553     {

   554     *lenptr = 1;

   555     return p + 1;

   556     }

   557   *lenptr = 0;

   558   return endptr;

   559 

   560   case EL_CRLF:

   561   for (;;)

   562     {

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

   564     if (++p >= endptr)

   565       {

   566       *lenptr = 0;

   567       return endptr;

   568       }

   569     if (*p == '\n')

   570       {

   571       *lenptr = 2;

   572       return p + 1;

   573       }

   574     }

   575   break;

   576 

   577   case EL_ANYCRLF:

   578   while (p < endptr)

   579     {

   580     int extra = 0;

   581     register int c = *((unsigned char *)p);

   582 

   583     if (utf8 && c >= 0xc0)

   584       {

   585       int gcii, gcss;

   586       extra = utf8_table4[c & 0x3f];  /* Number of additional bytes */

   587       gcss = 6*extra;

   588       c = (c & utf8_table3[extra]) << gcss;

   589       for (gcii = 1; gcii <= extra; gcii++)

   590         {

   591         gcss -= 6;

   592         c |= (p[gcii] & 0x3f) << gcss;

   593         }

   594       }

   595 

   596     p += 1 + extra;

   597 

   598     switch (c)

   599       {

   600       case 0x0a:    /* LF */

   601       *lenptr = 1;

   602       return p;

   603 

   604       case 0x0d:    /* CR */

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

   606         {

   607         *lenptr = 2;

   608         p++;

   609         }

   610       else *lenptr = 1;

   611       return p;

   612 

   613       default:

   614       break;

   615       }

   616     }   /* End of loop for ANYCRLF case */

   617 

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

   619   return endptr;

   620 

   621   case EL_ANY:

   622   while (p < endptr)

   623     {

   624     int extra = 0;

   625     register int c = *((unsigned char *)p);

   626 

   627     if (utf8 && c >= 0xc0)

   628       {

   629       int gcii, gcss;

   630       extra = utf8_table4[c & 0x3f];  /* Number of additional bytes */

   631       gcss = 6*extra;

   632       c = (c & utf8_table3[extra]) << gcss;

   633       for (gcii = 1; gcii <= extra; gcii++)

   634         {

   635         gcss -= 6;

   636         c |= (p[gcii] & 0x3f) << gcss;

   637         }

   638       }

   639 

   640     p += 1 + extra;

   641 

   642     switch (c)

   643       {

   644       case 0x0a:    /* LF */

   645       case 0x0b:    /* VT */

   646       case 0x0c:    /* FF */

   647       *lenptr = 1;

   648       return p;

   649 

   650       case 0x0d:    /* CR */

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

   652         {

   653         *lenptr = 2;

   654         p++;

   655         }

   656       else *lenptr = 1;

   657       return p;

   658 

   659       case 0x85:    /* NEL */

   660       *lenptr = utf8? 2 : 1;

   661       return p;

   662 

   663       case 0x2028:  /* LS */

   664       case 0x2029:  /* PS */

   665       *lenptr = 3;

   666       return p;

   667 

   668       default:

   669       break;

   670       }

   671     }   /* End of loop for ANY case */

   672 

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

   674   return endptr;

   675   }     /* End of overall switch */

   676 }

   677 

   678 

   679 

   680 /*************************************************

   681 *         Find start of previous line            *

   682 *************************************************/

   683 

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

   685 

   686 Arguments:

   687   p         start of the subsequent line

   688   startptr  start of available data

   689 

   690 Returns:    pointer to the start of the previous line

   691 */

   692 

   693 static char *

   694 previous_line(char *p, char *startptr)

   695 {

   696 switch(endlinetype)

   697   {

   698   default:      /* Just in case */

   699   case EL_LF:

   700   p--;

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

   702   return p;

   703 

   704   case EL_CR:

   705   p--;

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

   707   return p;

   708 

   709   case EL_CRLF:

   710   for (;;)

   711     {

   712     p -= 2;

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

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

   715     }

   716   return p;   /* But control should never get here */

   717 

   718   case EL_ANY:

   719   case EL_ANYCRLF:

   720   if (*(--p) == '\n' && p > startptr && p[-1] == '\r') p--;

   721   if (utf8) while ((*p & 0xc0) == 0x80) p--;

   722 

   723   while (p > startptr)

   724     {

   725     register int c;

   726     char *pp = p - 1;

   727 

   728     if (utf8)

   729       {

   730       int extra = 0;

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

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

   733       if (c >= 0xc0)

   734         {

   735         int gcii, gcss;

   736         extra = utf8_table4[c & 0x3f];  /* Number of additional bytes */

   737         gcss = 6*extra;

   738         c = (c & utf8_table3[extra]) << gcss;

   739         for (gcii = 1; gcii <= extra; gcii++)

   740           {

   741           gcss -= 6;

   742           c |= (pp[gcii] & 0x3f) << gcss;

   743           }

   744         }

   745       }

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

   747 

   748     if (endlinetype == EL_ANYCRLF) switch (c)

   749       {

   750       case 0x0a:    /* LF */

   751       case 0x0d:    /* CR */

   752       return p;

   753 

   754       default:

   755       break;

   756       }

   757 

   758     else switch (c)

   759       {

   760       case 0x0a:    /* LF */

   761       case 0x0b:    /* VT */

   762       case 0x0c:    /* FF */

   763       case 0x0d:    /* CR */

   764       case 0x85:    /* NEL */

   765       case 0x2028:  /* LS */

   766       case 0x2029:  /* PS */

   767       return p;

   768 

   769       default:

   770       break;

   771       }

   772 

   773     p = pp;  /* Back one character */

   774     }        /* End of loop for ANY case */

   775 

   776   return startptr;  /* Hit start of data */

   777   }     /* End of overall switch */

   778 }

   779 

   780 

   781 

   782 

   783 

   784 /*************************************************

   785 *       Print the previous "after" lines         *

   786 *************************************************/

   787 

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

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

   790 that a binary zero does not terminate it.

   791 

   792 Arguments:

   793   lastmatchnumber   the number of the last matching line, plus one

   794   lastmatchrestart  where we restarted after the last match

   795   endptr            end of available data

   796   printname         filename for printing

   797 

   798 Returns:            nothing

   799 */

   800 

   801 static void do_after_lines(int lastmatchnumber, char *lastmatchrestart,

   802   char *endptr, char *printname)

   803 {

   804 if (after_context > 0 && lastmatchnumber > 0)

   805   {

   806   int count = 0;

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

   808     {

   809     int ellength;

   810     char *pp = lastmatchrestart;

   811     if (printname != NULL) fprintf(stdout, "%s-", printname);

   812     if (number) fprintf(stdout, "%d-", lastmatchnumber++);

   813     pp = end_of_line(pp, endptr, &ellength);

   814     fwrite(lastmatchrestart, 1, pp - lastmatchrestart, stdout);

   815     lastmatchrestart = pp;

   816     }

   817   hyphenpending = TRUE;

   818   }

   819 }

   820 

   821 

   822 

   823 /*************************************************

   824 *            Grep an individual file             *

   825 *************************************************/

   826 

   827 /* This is called from grep_or_recurse() below. It uses a buffer that is three

   828 times the value of MBUFTHIRD. The matching point is never allowed to stray into

   829 the top third of the buffer, thus keeping more of the file available for

   830 context printing or for multiline scanning. For large files, the pointer will

   831 be in the middle third most of the time, so the bottom third is available for

   832 "before" context printing.

   833 

   834 Arguments:

   835   handle       the fopened FILE stream for a normal file

   836                the gzFile pointer when reading is via libz

   837                the BZFILE pointer when reading is via libbz2

   838   frtype       FR_PLAIN, FR_LIBZ, or FR_LIBBZ2

   839   printname    the file name if it is to be printed for each match

   840                or NULL if the file name is not to be printed

   841                it cannot be NULL if filenames[_nomatch]_only is set

   842 

   843 Returns:       0 if there was at least one match

   844                1 otherwise (no matches)

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

   846 */

   847 

   848 static int

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

   850 {

   851 int rc = 1;

   852 int linenumber = 1;

   853 int lastmatchnumber = 0;

   854 int count = 0;

   855 int filepos = 0;

   856 int offsets[99];

   857 char *lastmatchrestart = NULL;

   858 char buffer[3*MBUFTHIRD];

   859 char *ptr = buffer;

   860 char *endptr;

   861 size_t bufflength;

   862 BOOL endhyphenpending = FALSE;

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

   864 

   865 #ifdef SUPPORT_LIBZ

   866 gzFile ingz = NULL;

   867 #endif

   868 

   869 #ifdef SUPPORT_LIBBZ2

   870 BZFILE *inbz2 = NULL;

   871 #endif

   872 

   873 

   874 /* Do the first read into the start of the buffer and set up the pointer to end

   875 of what we have. In the case of libz, a non-zipped .gz file will be read as a

   876 plain file. However, if a .bz2 file isn't actually bzipped, the first read will

   877 fail. */

   878 

   879 #ifdef SUPPORT_LIBZ

   880 if (frtype == FR_LIBZ)

   881   {

   882   ingz = (gzFile)handle;

   883   bufflength = gzread (ingz, buffer, 3*MBUFTHIRD);

   884   }

   885 else

   886 #endif

   887 

   888 #ifdef SUPPORT_LIBBZ2

   889 if (frtype == FR_LIBBZ2)

   890   {

   891   inbz2 = (BZFILE *)handle;

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

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

   894   }                                    /* without the cast it is unsigned. */

   895 else

   896 #endif

   897 

   898   {

   899   in = (FILE *)handle;

   900   bufflength = fread(buffer, 1, 3*MBUFTHIRD, in);

   901   }

   902 

   903 endptr = buffer + bufflength;

   904 

   905 /* Loop while the current pointer is not at the end of the file. For large

   906 files, endptr will be at the end of the buffer when we are in the middle of the

   907 file, but ptr will never get there, because as soon as it gets over 2/3 of the

   908 way, the buffer is shifted left and re-filled. */

   909 

   910 while (ptr < endptr)

   911   {

   912   int i, endlinelength;

   913   int mrc = 0;

   914   BOOL match = FALSE;

   915   char *matchptr = ptr;

   916   char *t = ptr;

   917   size_t length, linelength;

   918 

   919   /* At this point, ptr is at the start of a line. We need to find the length

   920   of the subject string to pass to pcre_exec(). In multiline mode, it is the

   921   length remainder of the data in the buffer. Otherwise, it is the length of

   922   the next line. After matching, we always advance by the length of the next

   923   line. In multiline mode the PCRE_FIRSTLINE option is used for compiling, so

   924   that any match is constrained to be in the first line. */

   925 

   926   t = end_of_line(t, endptr, &endlinelength);

   927   linelength = t - ptr - endlinelength;

   928   length = multiline? (size_t)(endptr - ptr) : linelength;

   929 

   930   /* Extra processing for Jeffrey Friedl's debugging. */

   931 

   932 #ifdef JFRIEDL_DEBUG

   933   if (jfriedl_XT || jfriedl_XR)

   934   {

   935       #include <sys/time.h>

   936       #include <time.h>

   937       struct timeval start_time, end_time;

   938       struct timezone dummy;

   939 

   940       if (jfriedl_XT)

   941       {

   942           unsigned long newlen = length * jfriedl_XT + strlen(jfriedl_prefix) + strlen(jfriedl_postfix);

   943           const char *orig = ptr;

   944           ptr = malloc(newlen + 1);

   945           if (!ptr) {

   946                   printf("out of memory");

   947                   exit(2);

   948           }

   949           endptr = ptr;

   950           strcpy(endptr, jfriedl_prefix); endptr += strlen(jfriedl_prefix);

   951           for (i = 0; i < jfriedl_XT; i++) {

   952                   strncpy(endptr, orig,  length);

   953                   endptr += length;

   954           }

   955           strcpy(endptr, jfriedl_postfix); endptr += strlen(jfriedl_postfix);

   956           length = newlen;

   957       }

   958 

   959       if (gettimeofday(&start_time, &dummy) != 0)

   960               perror("bad gettimeofday");

   961 

   962 

   963       for (i = 0; i < jfriedl_XR; i++)

   964           match = (pcre_exec(pattern_list[0], hints_list[0], ptr, length, 0, 0, offsets, 99) >= 0);

   965 

   966       if (gettimeofday(&end_time, &dummy) != 0)

   967               perror("bad gettimeofday");

   968 

   969       double delta = ((end_time.tv_sec + (end_time.tv_usec / 1000000.0))

   970                       -

   971                       (start_time.tv_sec + (start_time.tv_usec / 1000000.0)));

   972 

   973       printf("%s TIMER[%.4f]\n", match ? "MATCH" : "FAIL", delta);

   974       return 0;

   975   }

   976 #endif

   977 

   978   /* We come back here after a match when the -o option (only_matching) is set,

   979   in order to find any further matches in the same line. */

   980 

   981   ONLY_MATCHING_RESTART:

   982 

   983   /* Run through all the patterns until one matches. Note that we don't include

   984   the final newline in the subject string. */

   985 

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

   987     {

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

   989       offsets, 99);

   990     if (mrc >= 0) { match = TRUE; break; }

   991     if (mrc != PCRE_ERROR_NOMATCH)

   992       {

   993       fprintf(stderr, "pcregrep: pcre_exec() error %d while matching ", mrc);

   994       if (pattern_count > 1) fprintf(stderr, "pattern number %d to ", i+1);

   995       fprintf(stderr, "this line:\n");

   996       fwrite(matchptr, 1, linelength, stderr);  /* In case binary zero included */

   997       fprintf(stderr, "\n");

   998       if (error_count == 0 &&

   999           (mrc == PCRE_ERROR_MATCHLIMIT || mrc == PCRE_ERROR_RECURSIONLIMIT))

  1000         {

  1001         fprintf(stderr, "pcregrep: error %d means that a resource limit "

  1002           "was exceeded\n", mrc);

  1003         fprintf(stderr, "pcregrep: check your regex for nested unlimited loops\n");

  1004         }

  1005       if (error_count++ > 20)

  1006         {

  1007         fprintf(stderr, "pcregrep: too many errors - abandoned\n");

  1008         exit(2);

  1009         }

  1010       match = invert;    /* No more matching; don't show the line again */

  1011       break;

  1012       }

  1013     }

  1014 

  1015   /* If it's a match or a not-match (as required), do what's wanted. */

  1016 

  1017   if (match != invert)

  1018     {

  1019     BOOL hyphenprinted = FALSE;

  1020 

  1021     /* We've failed if we want a file that doesn't have any matches. */

  1022 

  1023     if (filenames == FN_NOMATCH_ONLY) return 1;

  1024 

  1025     /* Just count if just counting is wanted. */

  1026 

  1027     if (count_only) count++;

  1028 

  1029     /* If all we want is a file name, there is no need to scan any more lines

  1030     in the file. */

  1031 

  1032     else if (filenames == FN_ONLY)

  1033       {

  1034       fprintf(stdout, "%s\n", printname);

  1035       return 0;

  1036       }

  1037 

  1038     /* Likewise, if all we want is a yes/no answer. */

  1039 

  1040     else if (quiet) return 0;

  1041 

  1042     /* The --only-matching option prints just the substring that matched, and

  1043     the --file-offsets and --line-offsets options output offsets for the

  1044     matching substring (they both force --only-matching). None of these options

  1045     prints any context. Afterwards, adjust the start and length, and then jump

  1046     back to look for further matches in the same line. If we are in invert

  1047     mode, however, nothing is printed - this could be still useful because the

  1048     return code is set. */

  1049 

  1050     else if (only_matching)

  1051       {

  1052       if (!invert)

  1053         {

  1054         if (printname != NULL) fprintf(stdout, "%s:", printname);

  1055         if (number) fprintf(stdout, "%d:", linenumber);

  1056         if (line_offsets)

  1057           fprintf(stdout, "%d,%d", (int)(matchptr + offsets[0] - ptr),

  1058             offsets[1] - offsets[0]);

  1059         else if (file_offsets)

  1060           fprintf(stdout, "%d,%d", (int)(filepos + matchptr + offsets[0] - ptr),

  1061             offsets[1] - offsets[0]);

  1062         else

  1063           fwrite(matchptr + offsets[0], 1, offsets[1] - offsets[0], stdout);

  1064         fprintf(stdout, "\n");

  1065         matchptr += offsets[1];

  1066         length -= offsets[1];

  1067         match = FALSE;

  1068         goto ONLY_MATCHING_RESTART;

  1069         }

  1070       }

  1071 

  1072     /* This is the default case when none of the above options is set. We print

  1073     the matching lines(s), possibly preceded and/or followed by other lines of

  1074     context. */

  1075 

  1076     else

  1077       {

  1078       /* See if there is a requirement to print some "after" lines from a

  1079       previous match. We never print any overlaps. */

  1080 

  1081       if (after_context > 0 && lastmatchnumber > 0)

  1082         {

  1083         int ellength;

  1084         int linecount = 0;

  1085         char *p = lastmatchrestart;

  1086 

  1087         while (p < ptr && linecount < after_context)

  1088           {

  1089           p = end_of_line(p, ptr, &ellength);

  1090           linecount++;

  1091           }

  1092 

  1093         /* It is important to advance lastmatchrestart during this printing so

  1094         that it interacts correctly with any "before" printing below. Print

  1095         each line's data using fwrite() in case there are binary zeroes. */

  1096 

  1097         while (lastmatchrestart < p)

  1098           {

  1099           char *pp = lastmatchrestart;

  1100           if (printname != NULL) fprintf(stdout, "%s-", printname);

  1101           if (number) fprintf(stdout, "%d-", lastmatchnumber++);

  1102           pp = end_of_line(pp, endptr, &ellength);

  1103           fwrite(lastmatchrestart, 1, pp - lastmatchrestart, stdout);

  1104           lastmatchrestart = pp;

  1105           }

  1106         if (lastmatchrestart != ptr) hyphenpending = TRUE;

  1107         }

  1108 

  1109       /* If there were non-contiguous lines printed above, insert hyphens. */

  1110 

  1111       if (hyphenpending)

  1112         {

  1113         fprintf(stdout, "--\n");

  1114         hyphenpending = FALSE;

  1115         hyphenprinted = TRUE;

  1116         }

  1117 

  1118       /* See if there is a requirement to print some "before" lines for this

  1119       match. Again, don't print overlaps. */

  1120 

  1121       if (before_context > 0)

  1122         {

  1123         int linecount = 0;

  1124         char *p = ptr;

  1125 

  1126         while (p > buffer && (lastmatchnumber == 0 || p > lastmatchrestart) &&

  1127                linecount < before_context)

  1128           {

  1129           linecount++;

  1130           p = previous_line(p, buffer);

  1131           }

  1132 

  1133         if (lastmatchnumber > 0 && p > lastmatchrestart && !hyphenprinted)

  1134           fprintf(stdout, "--\n");

  1135