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

Diff of /code/trunk/pcregrep.c

Parent Directory | Revision Log | View Patch Patch

-revision 588 by ph10,
Sat Jan 15 11:22:47 2011 UTC
+revision 718 by ph10,
Wed Oct  5 16:11:19 2011 UTC
 Line 74 
 typedef int BOOL;
  #define OFFSET_SIZE 99
  #if BUFSIZ > 8192
- #define MBUFTHIRD BUFSIZ
+ #define PATBUFSIZE BUFSIZ
  #else
- #define MBUFTHIRD 8192
+ #define PATBUFSIZE 8192
  #endif
  /* Values for the "filenames" variable, which specifies options for file name
 Line 135 
 static char *colour_string = (char *)"1;
  static char *colour_option = NULL;
  static char *dee_option = NULL;
  static char *DEE_option = NULL;
+ static char *main_buffer = NULL;
  static char *newline = NULL;
  static char *pattern_filename = NULL;
  static char *stdin_name = (char *)"(standard input)";
-Line 159 
 static pcre *exclude_dir_compiled = NULL
+Line 160 
 static pcre *exclude_dir_compiled = NULL
  static int after_context = 0;
  static int before_context = 0;
  static int both_context = 0;
+ static int bufthird = PCREGREP_BUFSIZE;
+ static int bufsize = 3*PCREGREP_BUFSIZE;
  static int dee_action = dee_READ;
  static int DEE_action = DEE_READ;
  static int error_count = 0;
-Line 166 
 static int filenames = FN_DEFAULT;
+Line 169 
 static int filenames = FN_DEFAULT;
  static int only_matching = -1;
  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;
-Line 214 
 used to identify them. */
+Line 223 
 used to identify them. */
  #define N_LBUFFER      (-12)
  #define N_M_LIMIT      (-13)
  #define N_M_LIMIT_REC  (-14)
+ #define N_BUFSIZE      (-15)
+ #define N_NOJIT        (-16)
  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_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" },
-Line 233 
 static option_item optionlist[] = {
+Line 245 
 static option_item optionlist[] = {
    { 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" },
+ #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" },
-Line 310 
 pcregrep_exit(int rc)
+Line 327 
 pcregrep_exit(int rc)
  {
  if (resource_error)
    {
-   fprintf(stderr, "pcregrep: Error %d or %d means that a resource limit "
+   fprintf(stderr, "pcregrep: Error %d, %d or %d means that a resource limit "
-     "was exceeded.\n", PCRE_ERROR_MATCHLIMIT, PCRE_ERROR_RECURSIONLIMIT);
+     "was exceeded.\n", PCRE_ERROR_MATCHLIMIT, PCRE_ERROR_RECURSIONLIMIT,
+     PCRE_ERROR_JIT_STACKLIMIT);
    fprintf(stderr, "pcregrep: Check your regex for nested unlimited loops.\n");
    }
-Line 634 
 Arguments:
+Line 652 
 Arguments:
    endptr    end of available data
    lenptr    where to put the length of the eol sequence
- Returns:    pointer to the last byte of the line, including the newline byte(s)
+ Returns:    pointer after the last byte of the line,
+             including the newline byte(s)
  */
  static char *
-Line 935 
 is used multiple times for the same subj
+Line 954 
 is used multiple times for the same subj
  to find all possible matches.
  Arguments:
-   matchptr    the start of the subject
+   matchptr     the start of the subject
-   length      the length of the subject to match
+   length       the length of the subject to match
-   offsets     the offets vector to fill in
+   startoffset  where to start matching
-   mrc         address of where to put the result of pcre_exec()
+   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
-Line 946 
 Returns:      TRUE if there was a match
+Line 966 
 Returns:      TRUE if there was a match
  */
  static BOOL
- match_patterns(char *matchptr, size_t length, int *offsets, int *mrc)
+ match_patterns(char *matchptr, size_t length, int startoffset, int *offsets,
+   int *mrc)
  {
  int i;
  size_t slen = length;
-Line 958 
 if (slen > 200)
+Line 979 
 if (slen > 200)
    }
  for (i = 0; i < pattern_count; i++)
    {
-   *mrc = pcre_exec(pattern_list[i], hints_list[i], matchptr, (int)length, 0,
+   *mrc = pcre_exec(pattern_list[i], hints_list[i], matchptr, (int)length,
-     PCRE_NOTEMPTY, offsets, OFFSET_SIZE);
+     startoffset, PCRE_NOTEMPTY, offsets, OFFSET_SIZE);
    if (*mrc >= 0) return TRUE;
    if (*mrc == PCRE_ERROR_NOMATCH) continue;
    fprintf(stderr, "pcregrep: pcre_exec() gave error %d while matching ", *mrc);
-Line 967 
 for (i = 0; i < pattern_count; i++)
+Line 988 
 for (i = 0; i < pattern_count; i++)
    fprintf(stderr, "%s", msg);
    FWRITE(matchptr, 1, slen, stderr);   /* In case binary zero included */
    fprintf(stderr, "\n\n");
-   if (*mrc == PCRE_ERROR_MATCHLIMIT || *mrc == PCRE_ERROR_RECURSIONLIMIT)
+   if (*mrc == PCRE_ERROR_MATCHLIMIT || *mrc == PCRE_ERROR_RECURSIONLIMIT ||
+       *mrc == PCRE_ERROR_JIT_STACKLIMIT)
      resource_error = TRUE;
    if (error_count++ > 20)
      {
-Line 987 
 return FALSE;  /* No match, no errors */
+Line 1009 
 return FALSE;  /* No match, no errors */
  *************************************************/
  /* This is called from grep_or_recurse() below. It uses a buffer that is three
- times the value of MBUFTHIRD. The matching point is never allowed to stray into
+ times the value of bufthird. The matching point is never allowed to stray into
  the top third of the buffer, thus keeping more of the file available for
  context printing or for multiline scanning. For large files, the pointer will
  be in the middle third most of the time, so the bottom third is available for
-Line 998 
 Arguments:
+Line 1020 
 Arguments:
                 the gzFile pointer when reading is via libz
                 the BZFILE pointer when reading is via libbz2
    frtype       FR_PLAIN, FR_LIBZ, or FR_LIBBZ2
+   filename     the file name or NULL (for errors)
    printname    the file name if it is to be printed for each match
                 or NULL if the file name is not to be printed
                 it cannot be NULL if filenames[_nomatch]_only is set
  Returns:       0 if there was at least one match
 otherwise (no matches)
-if there is a read error on a .bz2 file
+if an overlong line is encountered
+if there is a read error on a .bz2 file
  */
  static int
- pcregrep(void *handle, int frtype, char *printname)
+ pcregrep(void *handle, int frtype, char *filename, char *printname)
  {
  int rc = 1;
  int linenumber = 1;
-Line 1017 
 int count = 0;
+Line 1041 
 int count = 0;
  int filepos = 0;
  int offsets[OFFSET_SIZE];
  char *lastmatchrestart = NULL;
- char buffer[3*MBUFTHIRD];
+ char *ptr = main_buffer;
- char *ptr = buffer;
  char *endptr;
  size_t bufflength;
  BOOL endhyphenpending = FALSE;
-Line 1043 
 fail. */
+Line 1066 
 fail. */
  if (frtype == FR_LIBZ)
    {
    ingz = (gzFile)handle;
-   bufflength = gzread (ingz, buffer, 3*MBUFTHIRD);
+   bufflength = gzread (ingz, main_buffer, bufsize);
    }
  else
  #endif
-Line 1052 
 else
+Line 1075 
 else
  if (frtype == FR_LIBBZ2)
    {
    inbz2 = (BZFILE *)handle;
-   bufflength = BZ2_bzread(inbz2, buffer, 3*MBUFTHIRD);
+   bufflength = BZ2_bzread(inbz2, main_buffer, bufsize);
    if ((int)bufflength < 0) return 2;   /* Gotcha: bufflength is size_t; */
    }                                    /* without the cast it is unsigned. */
  else
-Line 1062 
 else
+Line 1085 
 else
    in = (FILE *)handle;
    if (is_file_tty(in)) input_line_buffered = TRUE;
    bufflength = input_line_buffered?
-     read_one_line(buffer, 3*MBUFTHIRD, in) :
+     read_one_line(main_buffer, bufsize, in) :
-     fread(buffer, 1, 3*MBUFTHIRD, in);
+     fread(main_buffer, 1, bufsize, in);
    }
- endptr = buffer + bufflength;
+ endptr = main_buffer + bufflength;
  /* Loop while the current pointer is not at the end of the file. For large
  files, endptr will be at the end of the buffer when we are in the middle of the
-Line 1077 
 while (ptr < endptr)
+Line 1100 
 while (ptr < endptr)
    {
    int endlinelength;
    int mrc = 0;
+   int startoffset = 0;
    BOOL match;
    char *matchptr = ptr;
    char *t = ptr;
-Line 1094 
 while (ptr < endptr)
+Line 1118 
 while (ptr < endptr)
    linelength = t - ptr - endlinelength;
    length = multiline? (size_t)(endptr - ptr) : linelength;
+   /* Check to see if the line we are looking at extends right to the very end
+   of the buffer without a line terminator. This means the line is too long to
+   handle. */
+   if (endlinelength == 0 && t == main_buffer + bufsize)
+     {
+     fprintf(stderr, "pcregrep: line %d%s%s is too long for the internal buffer\n"
+                     "pcregrep: check the --buffer-size option\n",
+                     linenumber,
+                     (filename == NULL)? "" : " of file ",
+                     (filename == NULL)? "" : filename);
+     return 2;
+     }
    /* Extra processing for Jeffrey Friedl's debugging. */
  #ifdef JFRIEDL_DEBUG
-Line 1153 
 while (ptr < endptr)
+Line 1191 
 while (ptr < endptr)
    than NOMATCH. This code is in a subroutine so that it can be re-used for
    finding subsequent matches when colouring matched lines. */
-   match = match_patterns(matchptr, length, offsets, &mrc);
+   match = match_patterns(matchptr, length, startoffset, offsets, &mrc);
    /* If it's a match or a not-match (as required), do what's wanted. */
-Line 1186 
 while (ptr < endptr)
+Line 1224 
 while (ptr < endptr)
      captured portion of it, as long as this string is not empty, and the
      --file-offsets and --line-offsets options output offsets for the matching
      substring (they both force --only-matching = 0). None of these options
-     prints any context. Afterwards, adjust the start and length, and then jump
+     prints any context. Afterwards, adjust the start and then jump back to look
-     back to look for further matches in the same line. If we are in invert
+     for further matches in the same line. If we are in invert mode, however,
-     mode, however, nothing is printed and we do not restart - this could still
+     nothing is printed and we do not restart - this could still be useful
-     be useful because the return code is set. */
+     because the return code is set. */
      else if (only_matching >= 0)
        {
-Line 1216 
 while (ptr < endptr)
+Line 1254 
 while (ptr < endptr)
              }
            }
          else if (printname != NULL || number) fprintf(stdout, "\n");
-         matchptr += offsets[1];
-         length -= offsets[1];
          match = FALSE;
          if (line_buffered) fflush(stdout);
-         rc = 0;    /* Had some success */
+         rc = 0;                      /* Had some success */
+         startoffset = offsets[1];    /* Restart after the match */
          goto ONLY_MATCHING_RESTART;
          }
        }
-Line 1279 
 while (ptr < endptr)
+Line 1316 
 while (ptr < endptr)
          int linecount = 0;
          char *p = ptr;
-         while (p > buffer && (lastmatchnumber == 0 || p > lastmatchrestart) &&
+         while (p > main_buffer && (lastmatchnumber == 0 || p > lastmatchrestart) &&
                 linecount < before_context)
            {
            linecount++;
-           p = previous_line(p, buffer);
+           p = previous_line(p, main_buffer);
            }
          if (lastmatchnumber > 0 && p > lastmatchrestart && !hyphenprinted)
-Line 1349 
 while (ptr < endptr)
+Line 1386 
 while (ptr < endptr)
        /* We have to split the line(s) up if colouring, and search for further
        matches, but not of course if the line is a non-match. */
        if (do_colour && !invert)
          {
          int plength;
-         int last_offset = 0;
          FWRITE(ptr, 1, offsets[0], stdout);
          fprintf(stdout, "%c[%sm", 0x1b, colour_string);
          FWRITE(ptr + offsets[0], 1, offsets[1] - offsets[0], stdout);
          fprintf(stdout, "%c[00m", 0x1b);
          for (;;)
            {
-           last_offset += offsets[1];
+           startoffset = offsets[1];
-           matchptr += offsets[1];
+           if (startoffset >= (int)linelength + endlinelength ||
-           length -= offsets[1];
+               !match_patterns(matchptr, length, startoffset, offsets, &mrc))
-           if (last_offset >= linelength + endlinelength ||
+             break;
-               !match_patterns(matchptr, length, offsets, &mrc)) break;
+           FWRITE(matchptr + startoffset, 1, offsets[0] - startoffset, stdout);
-           FWRITE(matchptr, 1, offsets[0], stdout);
            fprintf(stdout, "%c[%sm", 0x1b, colour_string);
            FWRITE(matchptr + offsets[0], 1, offsets[1] - offsets[0], stdout);
            fprintf(stdout, "%c[00m", 0x1b);
            }
          /* In multiline mode, we may have already printed the complete line
          and its line-ending characters (if they matched the pattern), so there
          may be no more to print. */
-         plength = (linelength + endlinelength) - last_offset;
+         plength = (linelength + endlinelength) - startoffset;
-         if (plength > 0)
+         if (plength > 0) FWRITE(ptr + startoffset, 1, plength, stdout);
-           FWRITE(ptr + last_offset, 1, plength, stdout);
          }
        /* Not colouring; no need to search for further matches */
-Line 1426 
 while (ptr < endptr)
+Line 1460 
 while (ptr < endptr)
    /* If input is line buffered, and the buffer is not yet full, read another
    line and add it into the buffer. */
-   if (input_line_buffered && bufflength < sizeof(buffer))
+   if (input_line_buffered && bufflength < (size_t)bufsize)
      {
-     int add = read_one_line(ptr, sizeof(buffer) - (ptr - buffer), in);
+     int add = read_one_line(ptr, bufsize - (ptr - main_buffer), in);
      bufflength += add;
      endptr += add;
      }
-Line 1438 
 while (ptr < endptr)
+Line 1472 
 while (ptr < endptr)
 /3 and refill it. Before we do this, if some unprinted "after" lines are
    about to be lost, print them. */
-   if (bufflength >= sizeof(buffer) && ptr > buffer + 2*MBUFTHIRD)
+   if (bufflength >= (size_t)bufsize && ptr > main_buffer + 2*bufthird)
      {
      if (after_context > 0 &&
          lastmatchnumber > 0 &&
-         lastmatchrestart < buffer + MBUFTHIRD)
+         lastmatchrestart < main_buffer + bufthird)
        {
        do_after_lines(lastmatchnumber, lastmatchrestart, endptr, printname);
        lastmatchnumber = 0;
-Line 1450 
 while (ptr < endptr)
+Line 1484 
 while (ptr < endptr)
      /* Now do the shuffle */
-     memmove(buffer, buffer + MBUFTHIRD, 2*MBUFTHIRD);
+     memmove(main_buffer, main_buffer + bufthird, 2*bufthird);
-     ptr -= MBUFTHIRD;
+     ptr -= bufthird;
  #ifdef SUPPORT_LIBZ
      if (frtype == FR_LIBZ)
-       bufflength = 2*MBUFTHIRD +
+       bufflength = 2*bufthird +
-         gzread (ingz, buffer + 2*MBUFTHIRD, MBUFTHIRD);
+         gzread (ingz, main_buffer + 2*bufthird, bufthird);
      else
  #endif
  #ifdef SUPPORT_LIBBZ2
      if (frtype == FR_LIBBZ2)
-       bufflength = 2*MBUFTHIRD +
+       bufflength = 2*bufthird +
-         BZ2_bzread(inbz2, buffer + 2*MBUFTHIRD, MBUFTHIRD);
+         BZ2_bzread(inbz2, main_buffer + 2*bufthird, bufthird);
      else
  #endif
-     bufflength = 2*MBUFTHIRD +
+     bufflength = 2*bufthird +
        (input_line_buffered?
-        read_one_line(buffer + 2*MBUFTHIRD, MBUFTHIRD, in) :
+        read_one_line(main_buffer + 2*bufthird, bufthird, in) :
-        fread(buffer + 2*MBUFTHIRD, 1, MBUFTHIRD, in));
+        fread(main_buffer + 2*bufthird, 1, bufthird, in));
-     endptr = buffer + bufflength;
+     endptr = main_buffer + bufflength;
      /* Adjust any last match point */
-     if (lastmatchnumber > 0) lastmatchrestart -= MBUFTHIRD;
+     if (lastmatchnumber > 0) lastmatchrestart -= bufthird;
      }
    }     /* Loop through the whole file */
-Line 1555 
 BZFILE *inbz2 = NULL;
+Line 1589 
 BZFILE *inbz2 = NULL;
  if (strcmp(pathname, "-") == 0)
    {
-   return pcregrep(stdin, FR_PLAIN,
+   return pcregrep(stdin, FR_PLAIN, stdin_name,
      (filenames > FN_DEFAULT || (filenames == FN_DEFAULT && !only_one_at_top))?
        stdin_name : NULL);
    }
-Line 1687 
 if (handle == NULL)
+Line 1721 
 if (handle == NULL)
  /* Now grep the file */
- rc = pcregrep(handle, frtype, (filenames > FN_DEFAULT ||
+ rc = pcregrep(handle, frtype, pathname, (filenames > FN_DEFAULT ||
    (filenames == FN_DEFAULT && !only_one_at_top))? pathname : NULL);
  /* Close in an appropriate manner. */
-Line 1698 
 if (frtype == FR_LIBZ)
+Line 1732 
 if (frtype == FR_LIBZ)
  else
  #endif
- /* If it is a .bz2 file and the result is 2, it means that the first attempt to
+ /* If it is a .bz2 file and the result is 3, it means that the first attempt to
  read failed. If the error indicates that the file isn't in fact bzipped, try
  again as a normal file. */
  #ifdef SUPPORT_LIBBZ2
  if (frtype == FR_LIBBZ2)
    {
-   if (rc == 2)
+   if (rc == 3)
      {
      int errnum;
      const char *err = BZ2_bzerror(inbz2, &errnum);
-Line 1717 
 if (frtype == FR_LIBBZ2)
+Line 1751 
 if (frtype == FR_LIBBZ2)
      else if (!silent)
        fprintf(stderr, "pcregrep: Failed to read %s using bzlib: %s\n",
          pathname, err);
+     rc = 2;    /* The normal "something went wrong" code */
      }
    BZ2_bzclose(inbz2);
    }
-Line 1809 
 for (op = optionlist; op->one_char != 0;
+Line 1844 
 for (op = optionlist; op->one_char != 0;
    printf("%.*s%s\n", n, "                     ", op->help_text);
    }
- printf("\nWhen reading patterns from a file instead of using a command line option,\n");
+ printf("\nNumbers may be followed by K or M, e.g. --buffer-size=100K.\n");
+ printf("The default value for --buffer-size is %d.\n", PCREGREP_BUFSIZE);
+ printf("When reading patterns from a file instead of using a command line option,\n");
  printf("trailing white space is removed and blank lines are ignored.\n");
- printf("There is a maximum of %d patterns.\n", MAX_PATTERN_COUNT);
+ printf("There is a maximum of %d patterns, each of maximum size %d bytes.\n",
+   MAX_PATTERN_COUNT, PATBUFSIZE);
  printf("\nWith no FILEs, read standard input. If fewer than two FILEs given, assume -h.\n");
  printf("Exit status is 0 if any matches, 1 if no matches, and 2 if trouble.\n");
-Line 1831 
 switch(letter)
+Line 1869 
 switch(letter)
    {
    case N_FOFFSETS: file_offsets = TRUE; break;
    case N_HELP: help(); pcregrep_exit(0);
-   case N_LOFFSETS: line_offsets = number = TRUE; break;
    case N_LBUFFER: line_buffered = TRUE; break;
+   case N_LOFFSETS: line_offsets = number = TRUE; break;
+   case N_NOJIT: study_options &= ~PCRE_STUDY_JIT_COMPILE; break;
    case 'c': count_only = TRUE; break;
    case 'F': process_options |= PO_FIXED_STRINGS; break;
    case 'H': filenames = FN_FORCE; break;
-Line 1913 
 Returns:         TRUE on success, FALSE
+Line 1952 
 Returns:         TRUE on success, FALSE
  static BOOL
  compile_single_pattern(char *pattern, int options, char *filename, int count)
  {
- char buffer[MBUFTHIRD + 16];
+ char buffer[PATBUFSIZE];
  const char *error;
  int errptr;
-Line 1924 
 if (pattern_count >= MAX_PATTERN_COUNT)
+Line 1963 
 if (pattern_count >= MAX_PATTERN_COUNT)
    return FALSE;
    }
- sprintf(buffer, "%s%.*s%s", prefix[process_options], MBUFTHIRD, pattern,
+ sprintf(buffer, "%s%.*s%s", prefix[process_options], bufthird, pattern,
    suffix[process_options]);
  pattern_list[pattern_count] =
    pcre_compile(buffer, options, &error, &errptr, pcretables);
-Line 1983 
 compile_pattern(char *pattern, int optio
+Line 2022 
 compile_pattern(char *pattern, int optio
  if ((process_options & PO_FIXED_STRINGS) != 0)
    {
    char *eop = pattern + strlen(pattern);
-   char buffer[MBUFTHIRD];
+   char buffer[PATBUFSIZE];
    for(;;)
      {
      int ellength;
-Line 2021 
 char *patterns[MAX_PATTERN_COUNT];
+Line 2060 
 char *patterns[MAX_PATTERN_COUNT];
  const char *locale_from = "--locale";
  const char *error;
+ #ifdef SUPPORT_PCREGREP_JIT
+ pcre_jit_stack *jit_stack = NULL;
+ #endif
  /* Set the default line ending value from the default in the PCRE library;
  "lf", "cr", "crlf", and "any" are supported. Anything else is treated as "lf".
  Note that the return values from pcre_config(), though derived from the ASCII
-Line 2295 
 for (i = 1; i < argc; i++)
+Line 2338 
 for (i = 1; i < argc; i++)
      while (*endptr != 0 && isspace((unsigned char)(*endptr))) endptr++;
      while (isdigit((unsigned char)(*endptr)))
        n = n * 10 + (int)(*endptr++ - '0');
+     if (toupper(*endptr) == 'K')
+       {
+       n *= 1024;
+       endptr++;
+       }
+     else if (toupper(*endptr) == 'M')
+       {
+       n *= 1024*1024;
+       endptr++;
+       }
      if (*endptr != 0)
        {
        if (longop)
-Line 2461 
 if (jfriedl_XT != 0 || jfriedl_XR != 0)
+Line 2514 
 if (jfriedl_XT != 0 || jfriedl_XR != 0)
    }
  #endif
- /* Get memory to store the pattern and hints lists. */
+ /* Get memory for the main buffer, and to store the pattern and hints lists. */
+ bufsize = 3*bufthird;
+ main_buffer = (char *)malloc(bufsize);
  pattern_list = (pcre **)malloc(MAX_PATTERN_COUNT * sizeof(pcre *));
  hints_list = (pcre_extra **)malloc(MAX_PATTERN_COUNT * sizeof(pcre_extra *));
- if (pattern_list == NULL || hints_list == NULL)
+ if (main_buffer == NULL || pattern_list == NULL || hints_list == NULL)
    {
    fprintf(stderr, "pcregrep: malloc failed\n");
    goto EXIT2;
-Line 2498 
 if (pattern_filename != NULL)
+Line 2553 
 if (pattern_filename != NULL)
    int linenumber = 0;
    FILE *f;
    char *filename;
-   char buffer[MBUFTHIRD];
+   char buffer[PATBUFSIZE];
    if (strcmp(pattern_filename, "-") == 0)
      {
-Line 2517 
 if (pattern_filename != NULL)
+Line 2572 
 if (pattern_filename != NULL)
      filename = pattern_filename;
      }
-   while (fgets(buffer, MBUFTHIRD, f) != NULL)
+   while (fgets(buffer, PATBUFSIZE, f) != NULL)
      {
      char *s = buffer + (int)strlen(buffer);
      while (s > buffer && isspace((unsigned char)(s[-1]))) s--;
-Line 2531 
 if (pattern_filename != NULL)
+Line 2586 
 if (pattern_filename != NULL)
    if (f != stdin) fclose(f);
    }
- /* Study the regular expressions, as we will be running them many times */
+ /* Study the regular expressions, as we will be running them many times. Unless
+ JIT has been explicitly disabled, arrange a stack for it to use. */
+ #ifdef SUPPORT_PCREGREP_JIT
+ if ((study_options & PCRE_STUDY_JIT_COMPILE) != 0)
+   jit_stack = pcre_jit_stack_alloc(32*1024, 1024*1024);
+ #endif
  for (j = 0; j < pattern_count; j++)
    {
-   hints_list[j] = pcre_study(pattern_list[j], 0, &error);
+   hints_list[j] = pcre_study(pattern_list[j], study_options, &error);
    if (error != NULL)
      {
      char s[16];
-Line 2544 
 for (j = 0; j < pattern_count; j++)
+Line 2605 
 for (j = 0; j < pattern_count; j++)
      goto EXIT2;
      }
    hint_count++;
+ #ifdef SUPPORT_PCREGREP_JIT
+   if (jit_stack != NULL && hints_list[j] != NULL)
+     pcre_assign_jit_stack(hints_list[j], NULL, jit_stack);
+ #endif
    }
  /* If --match-limit or --recursion-limit was set, put the value(s) into the
-Line 2629 
 if (include_dir_pattern != NULL)
+Line 2694 
 if (include_dir_pattern != NULL)
  if (i >= argc)
    {
-   rc = pcregrep(stdin, FR_PLAIN, (filenames > FN_DEFAULT)? stdin_name : NULL);
+   rc = pcregrep(stdin, FR_PLAIN, stdin_name,
+     (filenames > FN_DEFAULT)? stdin_name : NULL);
    goto EXIT;
    }
-Line 2649 
 for (; i < argc; i++)
+Line 2715 
 for (; i < argc; i++)
    }
  EXIT:
+ #ifdef SUPPORT_PCREGREP_JIT
+ if (jit_stack != NULL) pcre_jit_stack_free(jit_stack);
+ #endif
+ if (main_buffer != NULL) free(main_buffer);
  if (pattern_list != NULL)
    {
    for (i = 0; i < pattern_count; i++) free(pattern_list[i]);
-Line 2658 
 if (hints_list != NULL)
+Line 2728 
 if (hints_list != NULL)
    {
    for (i = 0; i < hint_count; i++)
      {
-     if (hints_list[i] != NULL) free(hints_list[i]);
+     if (hints_list[i] != NULL) pcre_free_study(hints_list[i]);
      }
    free(hints_list);
    }

 Legend:



Removed from v.588
 


changed lines


 
Added in v.718
 Legend:



Removed from v.588
 


changed lines


 
Added in v.718
-Removed from v.588
+Added in v.718

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12