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

Diff of /code/trunk/pcretest.c

Parent Directory | Revision Log | View Patch Patch

-revision 75 by nigel,
Sat Feb 24 21:40:37 2007 UTC
+revision 85 by nigel,
Sat Feb 24 21:41:13 2007 UTC
 Line 4
  /* This program was hacked up as a tester for PCRE. I really should have
  written it more tidily in the first place. Will I ever learn? It has grown and
- been extended and consequently is now rather untidy in places.
+ been extended and consequently is now rather, er, *very* untidy in places.
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 44 
 POSSIBILITY OF SUCH DAMAGE.
  #include <locale.h>
  #include <errno.h>
- /* We need the internal info for displaying the results of pcre_study(). Also
- for getting the opcodes for showing compiled code. */
  #define PCRE_SPY        /* For Win32 build, import data, not export */
- #include "internal.h"
+ /* We include pcre_internal.h because we need the internal info for displaying
+ the results of pcre_study() and we also need to know about the internal
+ macros, structures, and other internal data values; pcretest has "inside
+ information" compared to a program that strictly follows the PCRE API. */
+ #include "pcre_internal.h"
+ /* We need access to the data tables that PCRE uses. So as not to have to keep
+ two copies, we include the source file here, changing the names of the external
+ symbols to prevent clashes. */
+ #define _pcre_utf8_table1      utf8_table1
+ #define _pcre_utf8_table1_size utf8_table1_size
+ #define _pcre_utf8_table2      utf8_table2
+ #define _pcre_utf8_table3      utf8_table3
+ #define _pcre_utf8_table4      utf8_table4
+ #define _pcre_utt              utt
+ #define _pcre_utt_size         utt_size
+ #define _pcre_OP_lengths       OP_lengths
+ #include "pcre_tables.c"
+ /* We also need the pcre_printint() function for printing out compiled
+ patterns. This function is in a separate file so that it can be included in
+ pcre_compile.c when that module is compiled with debugging enabled. */
+ #include "pcre_printint.src"
  /* It is possible to compile this test program without including support for
  testing the POSIX interface, though this is not available via the standard
-Line 58 
 Makefile. */
+Line 83 
 Makefile. */
  #include "pcreposix.h"
  #endif
+ /* It is also possible, for the benefit of the version imported into Exim, to
+ build pcretest without support for UTF8 (define NOUTF8), without the interface
+ to the DFA matcher (NODFA), and without the doublecheck of the old "info"
+ function (define NOINFOCHECK). */
+ /* Other parameters */
  #ifndef CLOCKS_PER_SEC
  #ifdef CLK_TCK
  #define CLOCKS_PER_SEC CLK_TCK
-Line 73 
 Makefile. */
+Line 106 
 Makefile. */
  #define DBUFFER_SIZE BUFFER_SIZE
+ /* Static variables */
  static FILE *outfile;
  static int log_store = 0;
  static int callout_count;
-Line 87 
 static size_t gotten_store;
+Line 122 
 static size_t gotten_store;
  static uschar *pbuffer = NULL;
- static const int utf8_table1[] = {
-x0000007f, 0x000007ff, 0x0000ffff, 0x001fffff, 0x03ffffff, 0x7fffffff};
- static const int utf8_table2[] = {
-, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc};
- static const int utf8_table3[] = {
-xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};
- /*************************************************
- *         Print compiled regex                   *
- *************************************************/
- /* The code for doing this is held in a separate file that is also included in
- pcre.c when it is compiled with the debug switch. It defines a function called
- print_internals(), which uses a table of opcode lengths defined by the macro
- OP_LENGTHS, whose name must be OP_lengths. It also uses a table that translates
- Unicode property names to numbers; this is kept in a separate file. */
- static uschar OP_lengths[] = { OP_LENGTHS };
- #include "ucp.h"
- #include "ucptypetable.c"
- #include "printint.c"
  /*************************************************
  *          Read number from string               *
-Line 143 
 return(result);
+Line 150 
 return(result);
- /*************************************************
- *       Convert character value to UTF-8         *
- *************************************************/
- /* This function takes an integer value in the range 0 - 0x7fffffff
- and encodes it as a UTF-8 character in 0 to 6 bytes.
- Arguments:
-   cvalue     the character value
-   buffer     pointer to buffer for result - at least 6 bytes long
- Returns:     number of characters placed in the buffer
-              -1 if input character is negative
-if input character is positive but too big (only when
-              int is longer than 32 bits)
- */
- static int
- ord2utf8(int cvalue, unsigned char *buffer)
- {
- register int i, j;
- for (i = 0; i < sizeof(utf8_table1)/sizeof(int); i++)
-   if (cvalue <= utf8_table1[i]) break;
- if (i >= sizeof(utf8_table1)/sizeof(int)) return 0;
- if (cvalue < 0) return -1;
- buffer += i;
- for (j = i; j > 0; j--)
-  {
-  *buffer-- = 0x80 | (cvalue & 0x3f);
-  cvalue >>= 6;
-  }
- *buffer = utf8_table2[i] | cvalue;
- return i + 1;
- }
  /*************************************************
  *            Convert UTF-8 string to value       *
-Line 195 
 Returns:   >  0 => the number of bytes c
+Line 166 
 Returns:   >  0 => the number of bytes c
             -6 to 0 => malformed UTF-8 character at offset = (-return)
  */
+ #if !defined NOUTF8
  static int
  utf82ord(unsigned char *buffer, int *vptr)
  {
-Line 226 
 for (j = 0; j < i; j++)
+Line 199 
 for (j = 0; j < i; j++)
  /* Check that encoding was the correct unique one */
- for (j = 0; j < sizeof(utf8_table1)/sizeof(int); j++)
+ for (j = 0; j < utf8_table1_size; j++)
    if (d <= utf8_table1[j]) break;
  if (j != i) return -(i+1);
-Line 236 
 if (j != i) return -(i+1);
+Line 209 
 if (j != i) return -(i+1);
  return i+1;
  }
+ #endif
+ /*************************************************
+ *       Convert character value to UTF-8         *
+ *************************************************/
+ /* This function takes an integer value in the range 0 - 0x7fffffff
+ and encodes it as a UTF-8 character in 0 to 6 bytes.
+ Arguments:
+   cvalue     the character value
+   buffer     pointer to buffer for result - at least 6 bytes long
+ Returns:     number of characters placed in the buffer
+ */
+ static int
+ ord2utf8(int cvalue, uschar *buffer)
+ {
+ register int i, j;
+ for (i = 0; i < utf8_table1_size; i++)
+   if (cvalue <= utf8_table1[i]) break;
+ buffer += i;
+ for (j = i; j > 0; j--)
+  {
+  *buffer-- = 0x80 | (cvalue & 0x3f);
+  cvalue >>= 6;
+  }
+ *buffer = utf8_table2[i] | cvalue;
+ return i + 1;
+ }
  /*************************************************
-Line 248 
 chars without printing. */
+Line 255 
 chars without printing. */
  static int pchars(unsigned char *p, int length, FILE *f)
  {
- int c;
+ int c = 0;
  int yield = 0;
  while (length-- > 0)
    {
+ #if !defined NOUTF8
    if (use_utf8)
      {
      int rc = utf82ord(p, &c);
-Line 275 
 while (length-- > 0)
+Line 283 
 while (length-- > 0)
        continue;
        }
      }
+ #endif
     /* Not UTF-8, or malformed UTF-8  */
-Line 403 
 static void *new_malloc(size_t size)
+Line 412 
 static void *new_malloc(size_t size)
  void *block = malloc(size);
  gotten_store = size;
  if (show_malloc)
-   fprintf(outfile, "malloc       %3d %p\n", size, block);
+   fprintf(outfile, "malloc       %3d %p\n", (int)size, block);
  return block;
  }
-Line 421 
 static void *stack_malloc(size_t size)
+Line 430 
 static void *stack_malloc(size_t size)
  {
  void *block = malloc(size);
  if (show_malloc)
-   fprintf(outfile, "stack_malloc %3d %p\n", size, block);
+   fprintf(outfile, "stack_malloc %3d %p\n", (int)size, block);
  return block;
  }
-Line 484 
 int showinfo = 0;
+Line 493 
 int showinfo = 0;
  int showstore = 0;
  int size_offsets = 45;
  int size_offsets_max;
- int *offsets;
+ int *offsets = NULL;
  #if !defined NOPOSIX
  int posix = 0;
  #endif
  int debug = 0;
  int done = 0;
+ int all_use_dfa = 0;
+ int yield = 0;
  unsigned char *buffer;
  unsigned char *dbuffer;
-Line 522 
 while (argc > 1 && argv[op][0] == '-')
+Line 533 
 while (argc > 1 && argv[op][0] == '-')
    else if (strcmp(argv[op], "-t") == 0) timeit = 1;
    else if (strcmp(argv[op], "-i") == 0) showinfo = 1;
    else if (strcmp(argv[op], "-d") == 0) showinfo = debug = 1;
+ #if !defined NODFA
+   else if (strcmp(argv[op], "-dfa") == 0) all_use_dfa = 1;
+ #endif
    else if (strcmp(argv[op], "-o") == 0 && argc > 2 &&
        ((size_offsets = get_value((unsigned char *)argv[op+1], &endptr)),
          *endptr == 0))
-Line 558 
 while (argc > 1 && argv[op][0] == '-')
+Line 572 
 while (argc > 1 && argv[op][0] == '-')
      printf("** Unknown or malformed option %s\n", argv[op]);
      printf("Usage:   pcretest [-d] [-i] [-o <n>] [-p] [-s] [-t] [<input> [<output>]]\n");
      printf("  -C     show PCRE compile-time options and exit\n");
-     printf("  -d     debug: show compiled code; implies -i\n"
+     printf("  -d     debug: show compiled code; implies -i\n");
-            "  -i     show information about compiled pattern\n"
+ #if !defined NODFA
+     printf("  -dfa   force DFA matching for all subjects\n");
+ #endif
+     printf("  -i     show information about compiled pattern\n"
             "  -m     output memory used information\n"
             "  -o <n> set size of offsets vector to <n>\n");
  #if !defined NOPOSIX
-Line 567 
 while (argc > 1 && argv[op][0] == '-')
+Line 584 
 while (argc > 1 && argv[op][0] == '-')
  #endif
      printf("  -s     output store (memory) used information\n"
             "  -t     time compilation and execution\n");
-     return 1;
+     yield = 1;
+     goto EXIT;
      }
    op++;
    argc--;
-Line 581 
 if (offsets == NULL)
+Line 599 
 if (offsets == NULL)
    {
    printf("** Failed to get %d bytes of memory for offsets vector\n",
      size_offsets_max * sizeof(int));
-   return 1;
+   yield = 1;
+   goto EXIT;
    }
  /* Sort out the input and output files */
-Line 592 
 if (argc > 1)
+Line 611 
 if (argc > 1)
    if (infile == NULL)
      {
      printf("** Failed to open %s\n", argv[op]);
-     return 1;
+     yield = 1;
+     goto EXIT;
      }
    }
-Line 602 
 if (argc > 2)
+Line 622 
 if (argc > 2)
    if (outfile == NULL)
      {
      printf("** Failed to open %s\n", argv[op+1]);
-     return 1;
+     yield = 1;
+     goto EXIT;
      }
    }
-Line 802 
 while (!done)
+Line 823 
 while (!done)
      {
      switch (*pp++)
        {
+       case 'f': options |= PCRE_FIRSTLINE; break;
        case 'g': do_g = 1; break;
        case 'i': options |= PCRE_CASELESS; break;
        case 'm': options |= PCRE_MULTILINE; break;
-Line 831 
 while (!done)
+Line 853 
 while (!done)
        case 'L':
        ppp = pp;
-       while (*ppp != '\n' && *ppp != ' ') ppp++;
+       /* The '\r' test here is so that it works on Windows */
+       while (*ppp != '\n' && *ppp != '\r' && *ppp != ' ') ppp++;
        *ppp = 0;
        if (setlocale(LC_CTYPE, (const char *)pp) == NULL)
          {
-Line 849 
 while (!done)
+Line 872 
 while (!done)
        *pp = 0;
        break;
-       case '\n': case ' ': break;
+       case '\r':                      /* So that it works in Windows */
+       case '\n':
+       case ' ':
+       break;
        default:
        fprintf(outfile, "** Unknown option '%c'\n", pp[-1]);
-Line 869 
 while (!done)
+Line 895 
 while (!done)
      if ((options & PCRE_CASELESS) != 0) cflags |= REG_ICASE;
      if ((options & PCRE_MULTILINE) != 0) cflags |= REG_NEWLINE;
+     if ((options & PCRE_DOTALL) != 0) cflags |= REG_DOTALL;
      rc = regcomp(&preg, (char *)p, cflags);
      /* Compilation failed; go back for another re, skipping to blank line
-Line 1008 
 while (!done)
+Line 1035 
 while (!done)
      if (do_showinfo)
        {
        unsigned long int get_options, all_options;
+ #if !defined NOINFOCHECK
        int old_first_char, old_options, old_count;
+ #endif
        int count, backrefmax, first_char, need_char;
        int nameentrysize, namecount;
        const uschar *nametable;
-Line 1016 
 while (!done)
+Line 1045 
 while (!done)
        if (do_debug)
          {
          fprintf(outfile, "------------------------------------------------------------------\n");
-         print_internals(re, outfile);
+         pcre_printint(re, outfile);
          }
        new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);
-Line 1029 
 while (!done)
+Line 1058 
 while (!done)
        new_info(re, NULL, PCRE_INFO_NAMECOUNT, &namecount);
        new_info(re, NULL, PCRE_INFO_NAMETABLE, (void *)&nametable);
+ #if !defined NOINFOCHECK
        old_count = pcre_info(re, &old_options, &old_first_char);
        if (count < 0) fprintf(outfile,
          "Error %d from pcre_info()\n", count);
-Line 1046 
 while (!done)
+Line 1076 
 while (!done)
            "Options disagreement: pcre_fullinfo=%ld pcre_info=%d\n",
              get_options, old_options);
          }
+ #endif
        if (size != regex_gotten_store) fprintf(outfile,
          "Size disagreement: pcre_fullinfo=%d call to malloc for %d\n",
-         size, regex_gotten_store);
+         (int)size, (int)regex_gotten_store);
        fprintf(outfile, "Capturing subpattern count = %d\n", count);
        if (backrefmax > 0)
-Line 1080 
 while (!done)
+Line 1111 
 while (!done)
          fprintf(outfile, "Partial matching not supported\n");
        if (get_options == 0) fprintf(outfile, "No options\n");
-         else fprintf(outfile, "Options:%s%s%s%s%s%s%s%s%s%s\n",
+         else fprintf(outfile, "Options:%s%s%s%s%s%s%s%s%s%s%s\n",
            ((get_options & PCRE_ANCHORED) != 0)? " anchored" : "",
            ((get_options & PCRE_CASELESS) != 0)? " caseless" : "",
            ((get_options & PCRE_EXTENDED) != 0)? " extended" : "",
            ((get_options & PCRE_MULTILINE) != 0)? " multiline" : "",
+           ((get_options & PCRE_FIRSTLINE) != 0)? " firstline" : "",
            ((get_options & PCRE_DOTALL) != 0)? " dotall" : "",
            ((get_options & PCRE_DOLLAR_ENDONLY) != 0)? " dollar_endonly" : "",
            ((get_options & PCRE_EXTRA) != 0)? " extra" : "",
-Line 1222 
 while (!done)
+Line 1254 
 while (!done)
            }
          fclose(f);
          }
+       new_free(re);
+       if (extra != NULL) new_free(extra);
+       if (tables != NULL) new_free((void *)tables);
        continue;  /* With next regex */
        }
      }        /* End of non-POSIX compile */
-Line 1244 
 while (!done)
+Line 1280 
 while (!done)
      int gmatched = 0;
      int start_offset = 0;
      int g_notempty = 0;
+     int use_dfa = 0;
      options = 0;
-Line 1299 
 while (!done)
+Line 1336 
 while (!done)
          /* Handle \x{..} specially - new Perl thing for utf8 */
+ #if !defined NOUTF8
          if (*p == '{')
            {
            unsigned char *pt = p;
-Line 1317 
 while (!done)
+Line 1355 
 while (!done)
              }
            /* Not correct form; fall through */
            }
+ #endif
          /* Ordinary \x */
-Line 1397 
 while (!done)
+Line 1436 
 while (!done)
            }
          continue;
+ #if !defined NODFA
+         case 'D':
+ #if !defined NOPOSIX
+         if (posix || do_posix)
+           printf("** Can't use dfa matching in POSIX mode: \\D ignored\n");
+         else
+ #endif
+           use_dfa = 1;
+         continue;
+         case 'F':
+         options |= PCRE_DFA_SHORTEST;
+         continue;
+ #endif
          case 'G':
          if (isdigit(*p))
            {
-Line 1439 
 while (!done)
+Line 1493 
 while (!done)
              {
              printf("** Failed to get %d bytes of memory for offsets vector\n",
                size_offsets_max * sizeof(int));
-             return 1;
+             yield = 1;
+             goto EXIT;
              }
            }
          use_size_offsets = n;
-Line 1450 
 while (!done)
+Line 1505 
 while (!done)
          options |= PCRE_PARTIAL;
          continue;
+ #if !defined NODFA
+         case 'R':
+         options |= PCRE_DFA_RESTART;
+         continue;
+ #endif
          case 'S':
          show_malloc = 1;
          continue;
-Line 1467 
 while (!done)
+Line 1528 
 while (!done)
      *q = 0;
      len = q - dbuffer;
+     if ((all_use_dfa || use_dfa) && find_match_limit)
+       {
+       printf("**Match limit not relevant for DFA matching: ignored\n");
+       find_match_limit = 0;
+       }
      /* Handle matching via the POSIX interface, which does not
      support timing or playing with the match limit or callout data. */
-Line 1524 
 while (!done)
+Line 1591 
 while (!done)
          register int i;
          clock_t time_taken;
          clock_t start_time = clock();
+ #if !defined NODFA
+         if (all_use_dfa || use_dfa)
+           {
+           int workspace[1000];
+           for (i = 0; i < LOOPREPEAT; i++)
+             count = pcre_dfa_exec(re, NULL, (char *)bptr, len, start_offset,
+               options | g_notempty, use_offsets, use_size_offsets, workspace,
+               sizeof(workspace)/sizeof(int));
+           }
+         else
+ #endif
          for (i = 0; i < LOOPREPEAT; i++)
            count = pcre_exec(re, extra, (char *)bptr, len,
              start_offset, options | g_notempty, use_offsets, use_size_offsets);
          time_taken = clock() - start_time;
          fprintf(outfile, "Execute time %.3f milliseconds\n",
            (((double)time_taken * 1000.0) / (double)LOOPREPEAT) /
-Line 1597 
 while (!done)
+Line 1678 
 while (!done)
        /* The normal case is just to do the match once, with the default
        value of match_limit. */
-       else
+ #if !defined NODFA
+       else if (all_use_dfa || use_dfa)
          {
-         count = pcre_exec(re, extra, (char *)bptr, len,
+         int workspace[1000];
-           start_offset, options | g_notempty, use_offsets, use_size_offsets);
+         count = pcre_dfa_exec(re, NULL, (char *)bptr, len, start_offset,
+           options | g_notempty, use_offsets, use_size_offsets, workspace,
+           sizeof(workspace)/sizeof(int));
+         if (count == 0)
+           {
+           fprintf(outfile, "Matched, but too many subsidiary matches\n");
+           count = use_size_offsets/2;
+           }
          }
+ #endif
-       if (count == 0)
+       else
          {
-         fprintf(outfile, "Matched, but too many substrings\n");
+         count = pcre_exec(re, extra, (char *)bptr, len,
-         count = use_size_offsets/3;
+           start_offset, options | g_notempty, use_offsets, use_size_offsets);
+         if (count == 0)
+           {
+           fprintf(outfile, "Matched, but too many substrings\n");
+           count = use_size_offsets/3;
+           }
          }
        /* Matched */
-Line 1692 
 while (!done)
+Line 1787 
 while (!done)
        else if (count == PCRE_ERROR_PARTIAL)
          {
-         fprintf(outfile, "Partial match\n");
+         fprintf(outfile, "Partial match");
+ #if !defined NODFA
+         if ((all_use_dfa || use_dfa) && use_size_offsets > 2)
+           fprintf(outfile, ": %.*s", use_offsets[1] - use_offsets[0],
+             bptr + use_offsets[0]);
+ #endif
+         fprintf(outfile, "\n");
          break;  /* Out of the /g loop */
          }
-Line 1770 
 while (!done)
+Line 1871 
 while (!done)
    if (posix || do_posix) regfree(&preg);
  #endif
-   if (re != NULL) free(re);
+   if (re != NULL) new_free(re);
-   if (extra != NULL) free(extra);
+   if (extra != NULL) new_free(extra);
    if (tables != NULL)
      {
-     free((void *)tables);
+     new_free((void *)tables);
      setlocale(LC_CTYPE, "C");
      }
    }
  if (infile == stdin) fprintf(outfile, "\n");
- return 0;
+ EXIT:
+ if (infile != NULL && infile != stdin) fclose(infile);
+ if (outfile != NULL && outfile != stdout) fclose(outfile);
+ free(buffer);
+ free(dbuffer);
+ free(pbuffer);
+ free(offsets);
+ return yield;
  }
- /* End */
+ /* End of pcretest.c */

 Legend:



Removed from v.75
 


changed lines


 
Added in v.85
 Legend:



Removed from v.75
 


changed lines


 
Added in v.85
-Removed from v.75
+Added in v.85

	ViewVC Help
Powered by ViewVC 1.1.5