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

Diff of /code/trunk/pcretest.c

Parent Directory | Revision Log | View Patch Patch

-revision 642 by ph10,
Thu Jul 28 18:59:40 2011 UTC
+revision 675 by ph10,
Sat Aug 27 10:18:46 2011 UTC
 Line 112 
 to keep two copies, we include the sourc
  external symbols to prevent clashes. */
  #define _pcre_ucp_gentype      ucp_gentype
+ #define _pcre_ucp_typerange    ucp_typerange
  #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_utf8_char_sizes  utf8_char_sizes
  #define _pcre_utt              utt
  #define _pcre_utt_size         utt_size
  #define _pcre_utt_names        utt_names
-Line 189 
 static int locale_set = 0;
+Line 191 
 static int locale_set = 0;
  static int show_malloc;
  static int use_utf8;
  static size_t gotten_store;
+ static const unsigned char *last_callout_mark = NULL;
  /* The buffers grow automatically if very long input lines are encountered. */
-Line 207 
 static const char *errtexts[] = {
+Line 210 
 static const char *errtexts[] = {
    "magic number missing",
    "unknown opcode - pattern overwritten?",
    "no more memory",
    NULL,  /* never returned by pcre_exec() or pcre_dfa_exec() */
    "match limit exceeded",
    "callout error code",
    NULL,  /* BADUTF8 is handled specially */
-Line 220 
 static const char *errtexts[] = {
+Line 223 
 static const char *errtexts[] = {
    "backreference condition or recursion test not supported for DFA matching",
    "match limit not supported for DFA matching",
    "workspace size exceeded in DFA matching",
    "too much recursion for DFA matching",
    "recursion limit exceeded",
    "not used - internal error",
    "invalid combination of newline options",
-Line 228 
 static const char *errtexts[] = {
+Line 231 
 static const char *errtexts[] = {
    NULL,  /* SHORTUTF8 is handled specially */
    "nested recursion at the same subject position"
  };
  /*************************************************
  *         Alternate character tables             *
-Line 578 
 return sys_errlist[n];
+Line 581 
 return sys_errlist[n];
  #endif /* HAVE_STRERROR */
+ /*************************************************
+ *         JIT memory callback                    *
+ *************************************************/
+ static pcre_jit_stack* jit_callback(void *arg)
+ {
+ return (pcre_jit_stack *)arg;
+ }
  /*************************************************
-Line 960 
 fprintf(outfile, "%.*s", (cb->next_item_
+Line 971 
 fprintf(outfile, "%.*s", (cb->next_item_
  fprintf(outfile, "\n");
  first_callout = 0;
+ if (cb->mark != last_callout_mark)
+   {
+   fprintf(outfile, "Latest Mark: %s\n",
+     (cb->mark == NULL)? "<unset>" : (char *)(cb->mark));
+   last_callout_mark = cb->mark;
+   }
  if (cb->callout_data != NULL)
    {
    int callout_data = *((int *)(cb->callout_data));
-Line 979 
 return (cb->callout_number != callout_fa
+Line 997 
 return (cb->callout_number != callout_fa
  *            Local malloc functions              *
  *************************************************/
- /* Alternative malloc function, to test functionality and show the size of the
+ /* Alternative malloc function, to test functionality and save the size of a
- compiled re. */
+ compiled re. The show_malloc variable is set only during matching. */
  static void *new_malloc(size_t size)
  {
-Line 998 
 if (show_malloc)
+Line 1016 
 if (show_malloc)
  free(block);
  }
  /* For recursion malloc/free, to test stacking calls */
  static void *stack_malloc(size_t size)
-Line 1033 
 if ((rc = pcre_fullinfo(re, study, optio
+Line 1050 
 if ((rc = pcre_fullinfo(re, study, optio
  /*************************************************
+ *      Check for supported JIT architecture      *
+ *************************************************/
+ /* If it won't JIT-compile a very simple regex, return FALSE. */
+ static int check_jit_arch(void)
+ {
+ const char *error;
+ int erroffset, rc;
+ pcre *re = pcre_compile("abc", 0, &error, &erroffset, NULL);
+ pcre_extra *extra = pcre_study(re, PCRE_STUDY_JIT_COMPILE, &error);
+ rc = extra != NULL && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 &&
+   extra->executable_jit != NULL;
+ pcre_free_study(extra);
+ free(re);
+ return rc;
+ }
+ /*************************************************
  *         Byte flipping function                 *
  *************************************************/
-Line 1187 
 printf("  -p       use POSIX interface\n
+Line 1224 
 printf("  -p       use POSIX interface\n
  #endif
  printf("  -q       quiet: do not output PCRE version number at start\n");
  printf("  -S <n>   set stack size to <n> megabytes\n");
- printf("  -s       force each pattern to be studied\n"
+ printf("  -s       force each pattern to be studied at basic level\n"
+        "  -s+      force each pattern to be studied, using JIT if available\n"
         "  -t       time compilation and execution\n");
  printf("  -t <n>   time compilation and execution, repeating <n> times\n");
  printf("  -tm      time execution (matching) only\n");
-Line 1215 
 int timeit = 0;
+Line 1253 
 int timeit = 0;
  int timeitm = 0;
  int showinfo = 0;
  int showstore = 0;
- int force_study = 0;
+ int force_study = -1;
+ int force_study_options = 0;
  int quiet = 0;
  int size_offsets = 45;
  int size_offsets_max;
-Line 1229 
 int all_use_dfa = 0;
+Line 1268 
 int all_use_dfa = 0;
  int yield = 0;
  int stack_size;
+ pcre_jit_stack *jit_stack = NULL;
  /* These vectors store, end-to-end, a list of captured substring names. Assume
  that 1024 is plenty long enough for the few names we'll be testing. */
-Line 1265 
 while (argc > 1 && argv[op][0] == '-')
+Line 1307 
 while (argc > 1 && argv[op][0] == '-')
    unsigned char *endptr;
    if (strcmp(argv[op], "-m") == 0) showstore = 1;
-   else if (strcmp(argv[op], "-s") == 0) force_study = 1;
+   else if (strcmp(argv[op], "-s") == 0) force_study = 0;
+   else if (strcmp(argv[op], "-s+") == 0)
+     {
+     force_study = 1;
+     force_study_options = PCRE_STUDY_JIT_COMPILE;
+     }
    else if (strcmp(argv[op], "-q") == 0) quiet = 1;
    else if (strcmp(argv[op], "-b") == 0) debug = 1;
    else if (strcmp(argv[op], "-i") == 0) showinfo = 1;
-Line 1330 
 while (argc > 1 && argv[op][0] == '-')
+Line 1377 
 while (argc > 1 && argv[op][0] == '-')
      printf("  %sUTF-8 support\n", rc? "" : "No ");
      (void)pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &rc);
      printf("  %sUnicode properties support\n", rc? "" : "No ");
+     (void)pcre_config(PCRE_CONFIG_JIT, &rc);
+     if (rc)
+       printf("  Just-in-time compiler support%s\n", check_jit_arch()?
+         "" : " (but this architecture is unsupported)");
+     else
+       printf("  No just-in-time compiler support\n");
      (void)pcre_config(PCRE_CONFIG_NEWLINE, &rc);
      /* Note that these values are always the ASCII values, even
      in EBCDIC environments. CR is 13 and NL is 10. */
-Line 1435 
 while (!done)
+Line 1488 
 while (!done)
    const unsigned char *tables = NULL;
    unsigned long int true_size, true_study_size = 0;
    size_t size, regex_gotten_store;
    int do_allcaps = 0;
    int do_mark = 0;
    int do_study = 0;
    int no_force_study = 0;
    int do_debug = debug;
    int do_G = 0;
    int do_g = 0;
-Line 1530 
 while (!done)
+Line 1583 
 while (!done)
          {
          FAIL_READ:
          fprintf(outfile, "Failed to read data from %s\n", p);
-         if (extra != NULL) new_free(extra);
+         if (extra != NULL) pcre_free_study(extra);
          if (re != NULL) new_free(re);
          fclose(f);
          continue;
-Line 1596 
 while (!done)
+Line 1649 
 while (!done)
    /* Look for options after final delimiter */
    options = 0;
-   study_options = 0;
    log_store = showstore;  /* default from command line */
    while (*pp != 0)
-Line 1611 
 while (!done)
+Line 1663 
 while (!done)
        case 'x': options |= PCRE_EXTENDED; break;
        case '+':
        if (do_showrest) do_showcaprest = 1; else do_showrest = 1;
        break;
        case '=': do_allcaps = 1; break;
        case 'A': options |= PCRE_ANCHORED; break;
        case 'B': do_debug = 1; break;
        case 'C': options |= PCRE_AUTO_CALLOUT; break;
-Line 1632 
 while (!done)
+Line 1684 
 while (!done)
        case 'P': do_posix = 1; break;
  #endif
        case 'S':
-       if (do_study == 0) do_study = 1; else
+       if (do_study == 0)
+         {
+         do_study = 1;
+         if (*pp == '+')
+           {
+           study_options |= PCRE_STUDY_JIT_COMPILE;
+           pp++;
+           }
+         }
+       else
          {
          do_study = 0;
          no_force_study = 1;
          }
        break;
        case 'U': options |= PCRE_UNGREEDY; break;
-Line 1824 
 while (!done)
+Line 1885 
 while (!done)
      regex_gotten_store = gotten_store;
      /* If -s or /S was present, study the regex to generate additional info to
      help with the matching, unless the pattern has the SS option, which
      suppresses the effect of /S (used for a few test patterns where studying is
      never sensible). */
-     if (do_study || (force_study && !no_force_study))
+     if (do_study || (force_study >= 0 && !no_force_study))
        {
        if (timeit > 0)
          {
-Line 1836 
 while (!done)
+Line 1897 
 while (!done)
          clock_t time_taken;
          clock_t start_time = clock();
          for (i = 0; i < timeit; i++)
-           extra = pcre_study(re, study_options, &error);
+           extra = pcre_study(re, study_options | force_study_options, &error);
          time_taken = clock() - start_time;
-         if (extra != NULL) free(extra);
+         if (extra != NULL) pcre_free_study(extra);
          fprintf(outfile, "  Study time %.4f milliseconds\n",
            (((double)time_taken * 1000.0) / (double)timeit) /
              (double)CLOCKS_PER_SEC);
          }
-       extra = pcre_study(re, study_options, &error);
+       extra = pcre_study(re, study_options | force_study_options, &error);
        if (error != NULL)
          fprintf(outfile, "Failed to study: %s\n", error);
        else if (extra != NULL)
-Line 2066 
 while (!done)
+Line 2127 
 while (!done)
        /* Don't output study size; at present it is in any case a fixed
        value, but it varies, depending on the computer architecture, and
        so messes up the test suite. (And with the /F option, it might be
        flipped.) If study was forced by an external -s, don't show this
        information unless -i or -d was also present. This means that, except
        when auto-callouts are involved, the output from runs with and without
        -s should be identical. */
-       if (do_study || (force_study && showinfo && !no_force_study))
+       if (do_study || (force_study >= 0 && showinfo && !no_force_study))
          {
          if (extra == NULL)
            fprintf(outfile, "Study returned NULL\n");
-Line 2115 
 while (!done)
+Line 2176 
 while (!done)
              fprintf(outfile, "\n");
              }
            }
+         /* Show this only if the JIT was set by /S, not by -s. */
+         if ((study_options & PCRE_STUDY_JIT_COMPILE) != 0)
+           {
+           int jit;
+           new_info(re, extra, PCRE_INFO_JIT, &jit);
+           if (jit)
+             fprintf(outfile, "JIT study was successful\n");
+           else
+ #ifdef SUPPORT_JIT
+             fprintf(outfile, "JIT study was not successful\n");
+ #else
+             fprintf(outfile, "JIT support is not available in this version of PCRE\n");
+ #endif
+           }
          }
        }
-Line 2150 
 while (!done)
+Line 2227 
 while (!done)
          else
            {
            fprintf(outfile, "Compiled pattern written to %s\n", to_file);
-           /* If there is study data, write it, but verify the writing only
+           /* If there is study data, write it. */
-           if the studying was requested by /S, not just by -s. */
            if (extra != NULL)
              {
              if (fwrite(extra->study_data, 1, true_study_size, f) <
-Line 2169 
 while (!done)
+Line 2245 
 while (!done)
          }
        new_free(re);
-       if (extra != NULL) new_free(extra);
+       if (extra != NULL) pcre_free_study(extra);
        if (locale_set)
          {
          new_free((void *)tables);
-Line 2211 
 while (!done)
+Line 2287 
 while (!done)
      pcre_callout = callout;
      first_callout = 1;
+     last_callout_mark = NULL;
      callout_extra = 0;
      callout_count = 0;
      callout_fail_count = 999999;
-Line 2435 
 while (!done)
+Line 2512 
 while (!done)
            getnamesptr = npp;
            }
          continue;
+         case 'J':
+         while(isdigit(*p)) n = n * 10 + *p++ - '0';
+         if (extra != NULL
+             && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0
+             && extra->executable_jit != NULL)
+           {
+           if (jit_stack != NULL) pcre_jit_stack_free(jit_stack);
+           jit_stack = pcre_jit_stack_alloc(1, n * 1024);
+           pcre_assign_jit_stack(extra, jit_callback, jit_stack);
+           }
+         continue;
          case 'L':
          getlist = 1;
-Line 2646 
 while (!done)
+Line 2735 
 while (!done)
        /* If find_match_limit is set, we want to do repeated matches with
        varying limits in order to find the minimum value for the match limit and
-       for the recursion limit. */
+       for the recursion limit. The match limits are relevant only to the normal
+       running of pcre_exec(), so disable the JIT optimization. This makes it
+       possible to run the same set of tests with and without JIT externally
+       requested. */
        if (find_match_limit)
          {
-Line 2655 
 while (!done)
+Line 2747 
 while (!done)
            extra = (pcre_extra *)malloc(sizeof(pcre_extra));
            extra->flags = 0;
            }
+         else extra->flags &= ~PCRE_EXTRA_EXECUTABLE_JIT;
          (void)check_match_limit(re, extra, bptr, len, start_offset,
            options|g_notempty, use_offsets, use_size_offsets,
            PCRE_EXTRA_MATCH_LIMIT, &(extra->match_limit),
-Line 2737 
 while (!done)
+Line 2830 
 while (!done)
              do_g = do_G = FALSE;        /* Break g/G loop */
              }
            }
          /* do_allcaps requests showing of all captures in the pattern, to check
          unset ones at the end. */
          if (do_allcaps)
            {
            new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count);
            count++;   /* Allow for full match */
            if (count * 2 > use_size_offsets) count = use_size_offsets/2;
            }
          /* Output the captured substrings */
          for (i = 0; i < count * 2; i += 2)
            {
            if (use_offsets[i] < 0)
              {
              if (use_offsets[i] != -1)
                fprintf(outfile, "ERROR: bad negative value %d for offset %d\n",
                  use_offsets[i], i);
              if (use_offsets[i+1] != -1)
                fprintf(outfile, "ERROR: bad negative value %d for offset %d\n",
                  use_offsets[i+1], i+1);
              fprintf(outfile, "%2d: <unset>\n", i/2);
              }
            else
              {
              fprintf(outfile, "%2d: ", i/2);
-Line 2853 
 while (!done)
+Line 2946 
 while (!done)
                fprintf(outfile, "%2dL %s\n", i, stringlist[i]);
              if (stringlist[i] != NULL)
                fprintf(outfile, "string list not terminated by NULL\n");
-             /* free((void *)stringlist); */
              pcre_free_substring_list(stringlist);
              }
            }
-Line 2931 
 while (!done)
+Line 3023 
 while (!done)
          else
            {
            switch(count)
              {
              case PCRE_ERROR_NOMATCH:
              if (gmatched == 0)
                {
-Line 2939 
 while (!done)
+Line 3031 
 while (!done)
                  else fprintf(outfile, "No match, mark = %s\n", markptr);
                }
              break;
              case PCRE_ERROR_BADUTF8:
              case PCRE_ERROR_SHORTUTF8:
              fprintf(outfile, "Error %d (%s UTF-8 string)", count,
                (count == PCRE_ERROR_BADUTF8)? "bad" : "short");
              if (use_size_offsets >= 2)
                fprintf(outfile, " offset=%d reason=%d", use_offsets[0],
                  use_offsets[1]);
              fprintf(outfile, "\n");
              break;
              default:
              if (count < 0 && (-count) < sizeof(errtexts)/sizeof(const char *))
                fprintf(outfile, "Error %d (%s)\n", count, errtexts[-count]);
              else
                fprintf(outfile, "Error %d (Unexpected value)\n", count);
              break;
              }
            break;  /* Out of the /g loop */
            }
          }
-Line 3004 
 while (!done)
+Line 3096 
 while (!done)
  #endif
    if (re != NULL) new_free(re);
-   if (extra != NULL) new_free(extra);
+   if (extra != NULL) pcre_free_study(extra);
    if (locale_set)
      {
      new_free((void *)tables);
      setlocale(LC_CTYPE, "C");
      locale_set = 0;
      }
+   if (jit_stack != NULL)
+     {
+     pcre_jit_stack_free(jit_stack);
+     jit_stack = NULL;
+     }
    }
  if (infile == stdin) fprintf(outfile, "\n");

 Legend:



Removed from v.642
 


changed lines


 
Added in v.675
 Legend:



Removed from v.642
 


changed lines


 
Added in v.675
-Removed from v.642
+Added in v.675

	ViewVC Help
Powered by ViewVC 1.1.5