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

Diff of /code/trunk/pcregrep.c

Parent Directory | Revision Log | View Patch Patch

-revision 87 by nigel,
Sat Feb 24 21:41:21 2007 UTC
+revision 96 by nigel,
Fri Mar  2 13:10:43 2007 UTC
 Line 56 
 POSSIBILITY OF SUCH DAMAGE.
  typedef int BOOL;
- #define VERSION "4.2 09-Jan-2006"
+ #define VERSION "4.4 29-Nov-2006"
  #define MAX_PATTERN_COUNT 100
  #if BUFSIZ > 8192
 Line 65 
 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 82 
 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 97 
 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 134 
 static BOOL number = FALSE;
+Line 144 
 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 192 
 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 222 
 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 462 
 return sys_errlist[n];
+Line 484 
 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 718 
 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 781 
 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 794 
 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 928 
 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 947 
 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 975 
 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 983 
 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 1005 
 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 1050 
 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 1060 
 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 1322 
 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;
-Line 1152 
 return FALSE;
+Line 1437 
 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 1455 
 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 1493 
 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 1594 
 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 1657 
 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 1789 
 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 1842 
 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 1850 
 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. */

 Legend:



Removed from v.87
 


changed lines


 
Added in v.96
 Legend:



Removed from v.87
 


changed lines


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

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12