/[pcre]/code/tags/pcre-8.01/pcregrep.c

Diff of /code/tags/pcre-8.01/pcregrep.c

Parent Directory | Revision Log | View Patch Patch

-revision 87 by nigel,
Sat Feb 24 21:41:21 2007 UTC
+revision 121 by ph10,
Mon Mar 12 12:12:47 2007 UTC
 Line 6
  its pattern matching. On a Unix or Win32 system it can recurse into
  directories.
-            Copyright (c) 1997-2006 University of Cambridge
+            Copyright (c) 1997-2007 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 37 
 POSSIBILITY OF SUCH DAMAGE.
  -----------------------------------------------------------------------------
  */
+ #ifdef HAVE_CONFIG_H
+ #  include <config.h>
+ #endif
  #include <ctype.h>
  #include <locale.h>
  #include <stdio.h>
-Line 48 
 POSSIBILITY OF SUCH DAMAGE.
+Line 52 
 POSSIBILITY OF SUCH DAMAGE.
  #include <sys/stat.h>
  #include <unistd.h>
- #include "config.h"
  #include "pcre.h"
  #define FALSE 0
-Line 56 
 POSSIBILITY OF SUCH DAMAGE.
+Line 59 
 POSSIBILITY OF SUCH DAMAGE.
  typedef int BOOL;
- #define VERSION "4.2 09-Jan-2006"
  #define MAX_PATTERN_COUNT 100
  #if BUFSIZ > 8192
-Line 65 
 typedef int BOOL;
+Line 67 
 typedef int BOOL;
  #define MBUFTHIRD 8192
  #endif
  /* Values for the "filenames" variable, which specifies options for file name
  output. The order is important; it is assumed that a file name is wanted for
  all values greater than FN_DEFAULT. */
-Line 83 
 enum { DEE_READ, DEE_SKIP };
+Line 84 
 enum { DEE_READ, DEE_SKIP };
  #define PO_LINE_MATCH     0x0002
  #define PO_FIXED_STRINGS  0x0004
+ /* Line ending types */
+ enum { EL_LF, EL_CR, EL_CRLF, EL_ANY };
  /*************************************************
-Line 94 
 regular code. */
+Line 99 
 regular code. */
  #ifdef JFRIEDL_DEBUG
  static int S_arg = -1;
+ static unsigned int jfriedl_XR = 0; /* repeat regex attempt this many times */
+ static unsigned int jfriedl_XT = 0; /* replicate text this many times */
+ static const char *jfriedl_prefix = "";
+ static const char *jfriedl_postfix = "";
  #endif
+ static int  endlinetype;
  static char *colour_string = (char *)"1;31";
  static char *colour_option = NULL;
  static char *dee_option = NULL;
  static char *DEE_option = NULL;
+ static char *newline = NULL;
  static char *pattern_filename = NULL;
  static char *stdin_name = (char *)"(standard input)";
  static char *locale = NULL;
-Line 107 
 static char *locale = NULL;
+Line 119 
 static char *locale = NULL;
  static const unsigned char *pcretables = NULL;
  static int  pattern_count = 0;
- static pcre **pattern_list;
+ static pcre **pattern_list = NULL;
- static pcre_extra **hints_list;
+ static pcre_extra **hints_list = NULL;
  static char *include_pattern = NULL;
  static char *exclude_pattern = NULL;
-Line 134 
 static BOOL number = FALSE;
+Line 146 
 static BOOL number = FALSE;
  static BOOL only_matching = FALSE;
  static BOOL quiet = FALSE;
  static BOOL silent = FALSE;
+ static BOOL utf8 = FALSE;
  /* Structure for options and list of them */
-Line 181 
 static option_item optionlist[] = {
+Line 194 
 static option_item optionlist[] = {
    { OP_STRING,    N_LABEL,  &stdin_name,       "label=name",    "set name for standard input" },
    { OP_STRING,    N_LOCALE, &locale,           "locale=locale", "use the named locale" },
    { OP_NODATA,    'M',      NULL,              "multiline",     "run in multiline mode" },
+   { OP_STRING,    'N',      &newline,          "newline=type",  "specify newline type (CR, LR, CRLF)" },
    { OP_NODATA,    'n',      NULL,              "line-number",   "print line number with output lines" },
    { OP_NODATA,    'o',      NULL,              "only-matching", "show only the part of the line that matched" },
    { OP_NODATA,    'q',      NULL,              "quiet",         "suppress output, just set return code" },
-Line 210 
 static const char *prefix[] = {
+Line 224 
 static const char *prefix[] = {
  static const char *suffix[] = {
    "", "\\b", ")$",   ")$",   "\\E", "\\E\\b", "\\E)$",   "\\E)$" };
+ /* UTF-8 tables - used only when the newline setting is "all". */
+ 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,
+,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };
  /*************************************************
-Line 222 
 although at present the only ones are fo
+Line 246 
 although at present the only ones are fo
  /************* Directory scanning in Unix ***********/
- #if IS_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>
-Line 292 
 Lionel Fourquaux. David Burgess added a
+Line 316 
 Lionel Fourquaux. David Burgess added a
  when it did not exist. */
- #elif HAVE_WIN32API
+ #elif HAVE_WINDOWS_H
  #ifndef STRICT
  # define STRICT
-Line 414 
 FALSE;
+Line 438 
 FALSE;
  typedef void directory_type;
  int isdirectory(char *filename) { return 0; }
- directory_type * opendirectory(char *filename) {}
+ directory_type * opendirectory(char *filename) { return (directory_type*)0;}
- char *readdirectory(directory_type *dir) {}
+ char *readdirectory(directory_type *dir) { return (char*)0;}
  void closedirectory(directory_type *dir) {}
-Line 462 
 return sys_errlist[n];
+Line 486 
 return sys_errlist[n];
  /*************************************************
+ *             Find end of line                   *
+ *************************************************/
+ /* The length of the endline sequence that is found is set via lenptr. This may
+ be zero at the very end of the file if there is no line-ending sequence there.
+ Arguments:
+   p         current position in line
+   endptr    end of available data
+   lenptr    where to put the length of the eol sequence
+ Returns:    pointer to the last byte of the line
+ */
+ static char *
+ end_of_line(char *p, char *endptr, int *lenptr)
+ {
+ switch(endlinetype)
+   {
+   default:      /* Just in case */
+   case EL_LF:
+   while (p < endptr && *p != '\n') p++;
+   if (p < endptr)
+     {
+     *lenptr = 1;
+     return p + 1;
+     }
+   *lenptr = 0;
+   return endptr;
+   case EL_CR:
+   while (p < endptr && *p != '\r') p++;
+   if (p < endptr)
+     {
+     *lenptr = 1;
+     return p + 1;
+     }
+   *lenptr = 0;
+   return endptr;
+   case EL_CRLF:
+   for (;;)
+     {
+     while (p < endptr && *p != '\r') p++;
+     if (++p >= endptr)
+       {
+       *lenptr = 0;
+       return endptr;
+       }
+     if (*p == '\n')
+       {
+       *lenptr = 2;
+       return p + 1;
+       }
+     }
+   break;
+   case EL_ANY:
+   while (p < endptr)
+     {
+     int extra = 0;
+     register int c = *((unsigned char *)p);
+     if (utf8 && c >= 0xc0)
+       {
+       int gcii, gcss;
+       extra = utf8_table4[c & 0x3f];  /* Number of additional bytes */
+       gcss = 6*extra;
+       c = (c & utf8_table3[extra]) << gcss;
+       for (gcii = 1; gcii <= extra; gcii++)
+         {
+         gcss -= 6;
+         c |= (p[gcii] & 0x3f) << gcss;
+         }
+       }
+     p += 1 + extra;
+     switch (c)
+       {
+       case 0x0a:    /* LF */
+       case 0x0b:    /* VT */
+       case 0x0c:    /* FF */
+       *lenptr = 1;
+       return p;
+       case 0x0d:    /* CR */
+       if (p < endptr && *p == 0x0a)
+         {
+         *lenptr = 2;
+         p++;
+         }
+       else *lenptr = 1;
+       return p;
+       case 0x85:    /* NEL */
+       *lenptr = utf8? 2 : 1;
+       return p;
+       case 0x2028:  /* LS */
+       case 0x2029:  /* PS */
+       *lenptr = 3;
+       return p;
+       default:
+       break;
+       }
+     }   /* End of loop for ANY case */
+   *lenptr = 0;  /* Must have hit the end */
+   return endptr;
+   }     /* End of overall switch */
+ }
+ /*************************************************
+ *         Find start of previous line            *
+ *************************************************/
+ /* This is called when looking back for before lines to print.
+ Arguments:
+   p         start of the subsequent line
+   startptr  start of available data
+ Returns:    pointer to the start of the previous line
+ */
+ static char *
+ previous_line(char *p, char *startptr)
+ {
+ switch(endlinetype)
+   {
+   default:      /* Just in case */
+   case EL_LF:
+   p--;
+   while (p > startptr && p[-1] != '\n') p--;
+   return p;
+   case EL_CR:
+   p--;
+   while (p > startptr && p[-1] != '\n') p--;
+   return p;
+   case EL_CRLF:
+   for (;;)
+     {
+     p -= 2;
+     while (p > startptr && p[-1] != '\n') p--;
+     if (p <= startptr + 1 || p[-2] == '\r') return p;
+     }
+   return p;   /* But control should never get here */
+   case EL_ANY:
+   if (*(--p) == '\n' && p > startptr && p[-1] == '\r') p--;
+   if (utf8) while ((*p & 0xc0) == 0x80) p--;
+   while (p > startptr)
+     {
+     register int c;
+     char *pp = p - 1;
+     if (utf8)
+       {
+       int extra = 0;
+       while ((*pp & 0xc0) == 0x80) pp--;
+       c = *((unsigned char *)pp);
+       if (c >= 0xc0)
+         {
+         int gcii, gcss;
+         extra = utf8_table4[c & 0x3f];  /* Number of additional bytes */
+         gcss = 6*extra;
+         c = (c & utf8_table3[extra]) << gcss;
+         for (gcii = 1; gcii <= extra; gcii++)
+           {
+           gcss -= 6;
+           c |= (pp[gcii] & 0x3f) << gcss;
+           }
+         }
+       }
+     else c = *((unsigned char *)pp);
+     switch (c)
+       {
+       case 0x0a:    /* LF */
+       case 0x0b:    /* VT */
+       case 0x0c:    /* FF */
+       case 0x0d:    /* CR */
+       case 0x85:    /* NEL */
+       case 0x2028:  /* LS */
+       case 0x2029:  /* PS */
+       return p;
+       default:
+       break;
+       }
+     p = pp;  /* Back one character */
+     }        /* End of loop for ANY case */
+   return startptr;  /* Hit start of data */
+   }     /* End of overall switch */
+ }
+ /*************************************************
  *       Print the previous "after" lines         *
  *************************************************/
-Line 486 
 if (after_context > 0 && lastmatchnumber
+Line 720 
 if (after_context > 0 && lastmatchnumber
    int count = 0;
    while (lastmatchrestart < endptr && count++ < after_context)
      {
+     int ellength;
      char *pp = lastmatchrestart;
      if (printname != NULL) fprintf(stdout, "%s-", printname);
      if (number) fprintf(stdout, "%d-", lastmatchnumber++);
-     while (*pp != '\n') pp++;
+     pp = end_of_line(pp, endptr, &ellength);
-     fwrite(lastmatchrestart, 1, pp - lastmatchrestart + 1, stdout);
+     fwrite(lastmatchrestart, 1, pp - lastmatchrestart, stdout);
-     lastmatchrestart = pp + 1;
+     lastmatchrestart = pp;
      }
    hyphenpending = TRUE;
    }
-Line 548 
 way, the buffer is shifted left and re-f
+Line 783 
 way, the buffer is shifted left and re-f
  while (ptr < endptr)
    {
-   int i;
+   int i, endlinelength;
    int mrc = 0;
    BOOL match = FALSE;
    char *t = ptr;
-Line 561 
 while (ptr < endptr)
+Line 796 
 while (ptr < endptr)
    line. In multiline mode the PCRE_FIRSTLINE option is used for compiling, so
    that any match is constrained to be in the first line. */
-   linelength = 0;
+   t = end_of_line(t, endptr, &endlinelength);
-   while (t < endptr && *t++ != '\n') linelength++;
+   linelength = t - ptr - endlinelength;
    length = multiline? endptr - ptr : linelength;
+   /* Extra processing for Jeffrey Friedl's debugging. */
+ #ifdef JFRIEDL_DEBUG
+   if (jfriedl_XT || jfriedl_XR)
+   {
+       #include <sys/time.h>
+       #include <time.h>
+       struct timeval start_time, end_time;
+       struct timezone dummy;
+       if (jfriedl_XT)
+       {
+           unsigned long newlen = length * jfriedl_XT + strlen(jfriedl_prefix) + strlen(jfriedl_postfix);
+           const char *orig = ptr;
+           ptr = malloc(newlen + 1);
+           if (!ptr) {
+                   printf("out of memory");
+                   exit(2);
+           }
+           endptr = ptr;
+           strcpy(endptr, jfriedl_prefix); endptr += strlen(jfriedl_prefix);
+           for (i = 0; i < jfriedl_XT; i++) {
+                   strncpy(endptr, orig,  length);
+                   endptr += length;
+           }
+           strcpy(endptr, jfriedl_postfix); endptr += strlen(jfriedl_postfix);
+           length = newlen;
+       }
+       if (gettimeofday(&start_time, &dummy) != 0)
+               perror("bad gettimeofday");
+       for (i = 0; i < jfriedl_XR; i++)
+           match = (pcre_exec(pattern_list[0], hints_list[0], ptr, length, 0, 0, offsets, 99) >= 0);
+       if (gettimeofday(&end_time, &dummy) != 0)
+               perror("bad gettimeofday");
+       double delta = ((end_time.tv_sec + (end_time.tv_usec / 1000000.0))
+                       -
+                       (start_time.tv_sec + (start_time.tv_usec / 1000000.0)));
+       printf("%s TIMER[%.4f]\n", match ? "MATCH" : "FAIL", delta);
+       return 0;
+   }
+ #endif
    /* Run through all the patterns until one matches. Note that we don't include
    the final newline in the subject string. */
-Line 646 
 while (ptr < endptr)
+Line 930 
 while (ptr < endptr)
        if (after_context > 0 && lastmatchnumber > 0)
          {
+         int ellength;
          int linecount = 0;
          char *p = lastmatchrestart;
          while (p < ptr && linecount < after_context)
            {
-           while (*p != '\n') p++;
+           p = end_of_line(p, ptr, &ellength);
-           p++;
            linecount++;
            }
-Line 665 
 while (ptr < endptr)
+Line 949 
 while (ptr < endptr)
            char *pp = lastmatchrestart;
            if (printname != NULL) fprintf(stdout, "%s-", printname);
            if (number) fprintf(stdout, "%d-", lastmatchnumber++);
-           while (*pp != '\n') pp++;
+           pp = end_of_line(pp, endptr, &ellength);
-           fwrite(lastmatchrestart, 1, pp - lastmatchrestart + 1, stdout);
+           fwrite(lastmatchrestart, 1, pp - lastmatchrestart, stdout);
-           lastmatchrestart = pp + 1;
+           lastmatchrestart = pp;
            }
          if (lastmatchrestart != ptr) hyphenpending = TRUE;
          }
-Line 693 
 while (ptr < endptr)
+Line 977 
 while (ptr < endptr)
                 linecount < before_context)
            {
            linecount++;
-           p--;
+           p = previous_line(p, buffer);
-           while (p > buffer && p[-1] != '\n') p--;
            }
          if (lastmatchnumber > 0 && p > lastmatchrestart && !hyphenprinted)
-Line 702 
 while (ptr < endptr)
+Line 985 
 while (ptr < endptr)
          while (p < ptr)
            {
+           int ellength;
            char *pp = p;
            if (printname != NULL) fprintf(stdout, "%s-", printname);
            if (number) fprintf(stdout, "%d-", linenumber - linecount--);
-           while (*pp != '\n') pp++;
+           pp = end_of_line(pp, endptr, &ellength);
-           fwrite(p, 1, pp - p + 1, stdout);   /* In case binary zero */
+           fwrite(p, 1, pp - p, stdout);
-           p = pp + 1;
+           p = pp;
            }
          }
-Line 723 
 while (ptr < endptr)
+Line 1007 
 while (ptr < endptr)
        /* In multiline mode, we want to print to the end of the line in which
        the end of the matched string is found, so we adjust linelength and the
        line number appropriately. Because the PCRE_FIRSTLINE option is set, the
-       start of the match will always be before the first \n character. */
+       start of the match will always be before the first newline sequence. */
        if (multiline)
          {
+         int ellength;
          char *endmatch = ptr + offsets[1];
          t = ptr;
-         while (t < endmatch) { if (*t++ == '\n') linenumber++; }
+         while (t < endmatch)
-         while (endmatch < endptr && *endmatch != '\n') endmatch++;
+           {
-         linelength = endmatch - ptr;
+           t = end_of_line(t, endptr, &ellength);
+           if (t <= endmatch) linenumber++; else break;
+           }
+         endmatch = end_of_line(endmatch, endptr, &ellength);
+         linelength = endmatch - ptr - ellength;
          }
        /*** NOTE: Use only fwrite() to output the data line, so that binary
-Line 763 
 while (ptr < endptr)
+Line 1052 
 while (ptr < endptr)
          fprintf(stdout, "%c[00m", 0x1b);
          fwrite(ptr + offsets[1], 1, linelength - offsets[1], stdout);
          }
-       else fwrite(ptr, 1, linelength, stdout);
+       else fwrite(ptr, 1, linelength + endlinelength, stdout);
-       fprintf(stdout, "\n");
        }
      /* End of doing what has to be done for a match */
-Line 775 
 while (ptr < endptr)
+Line 1062 
 while (ptr < endptr)
      /* Remember where the last match happened for after_context. We remember
      where we are about to restart, and that line's number. */
-     lastmatchrestart = ptr + linelength + 1;
+     lastmatchrestart = ptr + linelength + endlinelength;
      lastmatchnumber = linenumber + 1;
      }
    /* Advance to after the newline and increment the line number. */
-   ptr += linelength + 1;
+   ptr += linelength + endlinelength;
    linenumber++;
    /* If we haven't yet reached the end of the file (the buffer is full), and
-Line 1037 
 switch(letter)
+Line 1324 
 switch(letter)
    case 'q': quiet = TRUE; break;
    case 'r': dee_action = dee_RECURSE; break;
    case 's': silent = TRUE; break;
-   case 'u': options |= PCRE_UTF8; break;
+   case 'u': options |= PCRE_UTF8; utf8 = TRUE; break;
    case 'v': invert = TRUE; break;
    case 'w': process_options |= PO_WORD_MATCH; break;
    case 'x': process_options |= PO_LINE_MATCH; break;
    case 'V':
-   fprintf(stderr, "pcregrep version %s using ", VERSION);
+   fprintf(stderr, "pcregrep version %s\n", pcre_version());
-   fprintf(stderr, "PCRE version %s\n", pcre_version());
    exit(0);
    break;
-Line 1152 
 return FALSE;
+Line 1438 
 return FALSE;
  *************************************************/
  /* When the -F option has been used, each string may be a list of strings,
- separated by newlines. They will be matched literally.
+ separated by line breaks. They will be matched literally.
  Arguments:
    pattern        the pattern string
-Line 1170 
 compile_pattern(char *pattern, int optio
+Line 1456 
 compile_pattern(char *pattern, int optio
  {
  if ((process_options & PO_FIXED_STRINGS) != 0)
    {
+   char *eop = pattern + strlen(pattern);
    char buffer[MBUFTHIRD];
    for(;;)
      {
-     char *p = strchr(pattern, '\n');
+     int ellength;
-     if (p == NULL)
+     char *p = end_of_line(pattern, eop, &ellength);
+     if (ellength == 0)
        return compile_single_pattern(pattern, options, filename, count);
-     sprintf(buffer, "%.*s", p - pattern, pattern);
+     sprintf(buffer, "%.*s", p - pattern - ellength, pattern);
-     pattern = p + 1;
+     pattern = p;
      if (!compile_single_pattern(buffer, options, filename, count))
        return FALSE;
      }
-Line 1206 
 char *patterns[MAX_PATTERN_COUNT];
+Line 1494 
 char *patterns[MAX_PATTERN_COUNT];
  const char *locale_from = "--locale";
  const char *error;
+ /* 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".
+ */
+ (void)pcre_config(PCRE_CONFIG_NEWLINE, &i);
+ switch(i)
+   {
+   default:                 newline = (char *)"lf"; break;
+   case '\r':               newline = (char *)"cr"; break;
+   case ('\r' << 8) | '\n': newline = (char *)"crlf"; break;
+   case -1:                 newline = (char *)"any"; break;
+   }
  /* Process the options */
  for (i = 1; i < argc; i++)
-Line 1294 
 for (i = 1; i < argc; i++)
+Line 1595 
 for (i = 1; i < argc; i++)
        }
      }
+   /* Jeffrey Friedl's debugging harness uses these additional options which
+   are not in the right form for putting in the option table because they use
+   only one hyphen, yet are more than one character long. By putting them
+   separately here, they will not get displayed as part of the help() output,
+   but I don't think Jeffrey will care about that. */
+ #ifdef JFRIEDL_DEBUG
+   else if (strcmp(argv[i], "-pre") == 0) {
+           jfriedl_prefix = argv[++i];
+           continue;
+   } else if (strcmp(argv[i], "-post") == 0) {
+           jfriedl_postfix = argv[++i];
+           continue;
+   } else if (strcmp(argv[i], "-XT") == 0) {
+           sscanf(argv[++i], "%d", &jfriedl_XT);
+           continue;
+   } else if (strcmp(argv[i], "-XR") == 0) {
+           sscanf(argv[++i], "%d", &jfriedl_XR);
+           continue;
+   }
+ #endif
    /* One-char options; many that have no data may be in a single argument; we
    continue till we hit the last one or one that needs data. */
-Line 1333 
 for (i = 1; i < argc; i++)
+Line 1658 
 for (i = 1; i < argc; i++)
    /* If the option type is OP_OP_STRING or OP_OP_NUMBER, it's an option that
    either has a value or defaults to something. It cannot have data in a
    separate item. At the moment, the only such options are "colo(u)r" and
-   Jeffrey Friedl's special debugging option. */
+   Jeffrey Friedl's special -S debugging option. */
    if (*option_data == 0 &&
        (op->type == OP_OP_STRING || op->type == OP_OP_NUMBER))
-Line 1465 
 if (colour_option != NULL && strcmp(colo
+Line 1790 
 if (colour_option != NULL && strcmp(colo
      }
    }
+ /* Interpret the newline type; the default settings are Unix-like. */
+ if (strcmp(newline, "cr") == 0 || strcmp(newline, "CR") == 0)
+   {
+   pcre_options |= PCRE_NEWLINE_CR;
+   endlinetype = EL_CR;
+   }
+ else if (strcmp(newline, "lf") == 0 || strcmp(newline, "LF") == 0)
+   {
+   pcre_options |= PCRE_NEWLINE_LF;
+   endlinetype = EL_LF;
+   }
+ else if (strcmp(newline, "crlf") == 0 || strcmp(newline, "CRLF") == 0)
+   {
+   pcre_options |= PCRE_NEWLINE_CRLF;
+   endlinetype = EL_CRLF;
+   }
+ else if (strcmp(newline, "any") == 0 || strcmp(newline, "ANY") == 0)
+   {
+   pcre_options |= PCRE_NEWLINE_ANY;
+   endlinetype = EL_ANY;
+   }
+ else
+   {
+   fprintf(stderr, "pcregrep: Invalid newline specifier \"%s\"\n", newline);
+   return 2;
+   }
  /* Interpret the text values for -d and -D */
  if (dee_option != NULL)
-Line 1490 
 if (DEE_option != NULL)
+Line 1843 
 if (DEE_option != NULL)
      }
    }
- /* Check the value for Jeff Friedl's debugging option. */
+ /* Check the values for Jeffrey Friedl's debugging options. */
  #ifdef JFRIEDL_DEBUG
  if (S_arg > 9)
-Line 1498 
 if (S_arg > 9)
+Line 1851 
 if (S_arg > 9)
    fprintf(stderr, "pcregrep: bad value for -S option\n");
    return 2;
    }
+ if (jfriedl_XT != 0 || jfriedl_XR != 0)
+   {
+   if (jfriedl_XT == 0) jfriedl_XT = 1;
+   if (jfriedl_XR == 0) jfriedl_XR = 1;
+   }
  #endif
  /* Get memory to store the pattern and hints lists. */
-Line 1508 
 hints_list = (pcre_extra **)malloc(MAX_P
+Line 1866 
 hints_list = (pcre_extra **)malloc(MAX_P
  if (pattern_list == NULL || hints_list == NULL)
    {
    fprintf(stderr, "pcregrep: malloc failed\n");
-   return 2;
+   goto EXIT2;
    }
  /* If no patterns were provided by -e, and there is no file provided by -f,
-Line 1527 
 for (j = 0; j < cmd_pattern_count; j++)
+Line 1885 
 for (j = 0; j < cmd_pattern_count; j++)
    {
    if (!compile_pattern(patterns[j], pcre_options, NULL,
         (j == 0 && cmd_pattern_count == 1)? 0 : j + 1))
-     return 2;
+     goto EXIT2;
    }
  /* Compile the regular expressions that are provided in a file. */
-Line 1551 
 if (pattern_filename != NULL)
+Line 1909 
 if (pattern_filename != NULL)
        {
        fprintf(stderr, "pcregrep: Failed to open %s: %s\n", pattern_filename,
          strerror(errno));
-       return 2;
+       goto EXIT2;
        }
      filename = pattern_filename;
      }
-Line 1564 
 if (pattern_filename != NULL)
+Line 1922 
 if (pattern_filename != NULL)
      linenumber++;
      if (buffer[0] == 0) continue;   /* Skip blank lines */
      if (!compile_pattern(buffer, pcre_options, filename, linenumber))
-       return 2;
+       goto EXIT2;
      }
    if (f != stdin) fclose(f);
-Line 1580 
 for (j = 0; j < pattern_count; j++)
+Line 1938 
 for (j = 0; j < pattern_count; j++)
      char s[16];
      if (pattern_count == 1) s[0] = 0; else sprintf(s, " number %d", j);
      fprintf(stderr, "pcregrep: Error while studying regex%s: %s\n", s, error);
-     return 2;
+     goto EXIT2;
      }
    }
-Line 1594 
 if (exclude_pattern != NULL)
+Line 1952 
 if (exclude_pattern != NULL)
      {
      fprintf(stderr, "pcregrep: Error in 'exclude' regex at offset %d: %s\n",
        errptr, error);
-     return 2;
+     goto EXIT2;
      }
    }
-Line 1606 
 if (include_pattern != NULL)
+Line 1964 
 if (include_pattern != NULL)
      {
      fprintf(stderr, "pcregrep: Error in 'include' regex at offset %d: %s\n",
        errptr, error);
-     return 2;
+     goto EXIT2;
      }
    }
  /* If there are no further arguments, do the business on stdin and exit. */
  if (i >= argc)
-   return pcregrep(stdin, (filenames > FN_DEFAULT)? stdin_name : NULL);
+   {
+   rc = pcregrep(stdin, (filenames > FN_DEFAULT)? stdin_name : NULL);
+   goto EXIT;
+   }
  /* Otherwise, work through the remaining arguments as files or directories.
  Pass in the fact that there is only one argument at top level - this suppresses
-Line 1630 
 for (; i < argc; i++)
+Line 1991 
 for (; i < argc; i++)
      else if (frc == 0 && rc == 1) rc = 0;
    }
+ EXIT:
+ if (pattern_list != NULL)
+   {
+   for (i = 0; i < pattern_count; i++) free(pattern_list[i]);
+   free(pattern_list);
+   }
+ if (hints_list != NULL)
+   {
+   for (i = 0; i < pattern_count; i++) free(hints_list[i]);
+   free(hints_list);
+   }
  return rc;
+ EXIT2:
+ rc = 2;
+ goto EXIT;
  }
  /* End of pcregrep */

 Legend:



Removed from v.87
 


changed lines


 
Added in v.121
 Legend:



Removed from v.87
 


changed lines


 
Added in v.121
-Removed from v.87
+Added in v.121

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12