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

Diff of /code/trunk/pcretest.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 558 by ph10, Tue Oct 26 15:26:45 2010 UTC revision 676 by ph10, Sat Aug 27 15:53:04 2011 UTC
# Line 79  input mode under Windows. */ Line 79  input mode under Windows. */
79  #define fileno _fileno  #define fileno _fileno
80  #endif  #endif
81    
82    /* A user sent this fix for Borland Builder 5 under Windows. */
83    
84    #ifdef __BORLANDC__
85    #define _setmode(handle, mode) setmode(handle, mode)
86    #endif
87    
88    /* Not Windows */
89    
90  #else  #else
91  #include <sys/time.h>          /* These two includes are needed */  #include <sys/time.h>          /* These two includes are needed */
92  #include <sys/resource.h>      /* for setrlimit(). */  #include <sys/resource.h>      /* for setrlimit(). */
# Line 104  to keep two copies, we include the sourc Line 112  to keep two copies, we include the sourc
112  external symbols to prevent clashes. */  external symbols to prevent clashes. */
113    
114  #define _pcre_ucp_gentype      ucp_gentype  #define _pcre_ucp_gentype      ucp_gentype
115    #define _pcre_ucp_typerange    ucp_typerange
116  #define _pcre_utf8_table1      utf8_table1  #define _pcre_utf8_table1      utf8_table1
117  #define _pcre_utf8_table1_size utf8_table1_size  #define _pcre_utf8_table1_size utf8_table1_size
118  #define _pcre_utf8_table2      utf8_table2  #define _pcre_utf8_table2      utf8_table2
119  #define _pcre_utf8_table3      utf8_table3  #define _pcre_utf8_table3      utf8_table3
120  #define _pcre_utf8_table4      utf8_table4  #define _pcre_utf8_table4      utf8_table4
121    #define _pcre_utf8_char_sizes  utf8_char_sizes
122  #define _pcre_utt              utt  #define _pcre_utt              utt
123  #define _pcre_utt_size         utt_size  #define _pcre_utt_size         utt_size
124  #define _pcre_utt_names        utt_names  #define _pcre_utt_names        utt_names
# Line 181  static int locale_set = 0; Line 191  static int locale_set = 0;
191  static int show_malloc;  static int show_malloc;
192  static int use_utf8;  static int use_utf8;
193  static size_t gotten_store;  static size_t gotten_store;
194    static const unsigned char *last_callout_mark = NULL;
195    
196  /* The buffers grow automatically if very long input lines are encountered. */  /* The buffers grow automatically if very long input lines are encountered. */
197    
# Line 189  static uschar *buffer = NULL; Line 200  static uschar *buffer = NULL;
200  static uschar *dbuffer = NULL;  static uschar *dbuffer = NULL;
201  static uschar *pbuffer = NULL;  static uschar *pbuffer = NULL;
202    
203    /* Textual explanations for runtime error codes */
204    
205    static const char *errtexts[] = {
206      NULL,  /* 0 is no error */
207      NULL,  /* NOMATCH is handled specially */
208      "NULL argument passed",
209      "bad option value",
210      "magic number missing",
211      "unknown opcode - pattern overwritten?",
212      "no more memory",
213      NULL,  /* never returned by pcre_exec() or pcre_dfa_exec() */
214      "match limit exceeded",
215      "callout error code",
216      NULL,  /* BADUTF8 is handled specially */
217      "bad UTF-8 offset",
218      NULL,  /* PARTIAL is handled specially */
219      "not used - internal error",
220      "internal error - pattern overwritten?",
221      "bad count value",
222      "item unsupported for DFA matching",
223      "backreference condition or recursion test not supported for DFA matching",
224      "match limit not supported for DFA matching",
225      "workspace size exceeded in DFA matching",
226      "too much recursion for DFA matching",
227      "recursion limit exceeded",
228      "not used - internal error",
229      "invalid combination of newline options",
230      "bad offset value",
231      NULL,  /* SHORTUTF8 is handled specially */
232      "nested recursion at the same subject position",
233      "JIT stack limit reached"
234    };
235    
236    
237  /*************************************************  /*************************************************
238  *         Alternate character tables             *  *         Alternate character tables             *
# Line 538  return sys_errlist[n]; Line 582  return sys_errlist[n];
582  #endif /* HAVE_STRERROR */  #endif /* HAVE_STRERROR */
583    
584    
585    /*************************************************
586    *         JIT memory callback                    *
587    *************************************************/
588    
589    static pcre_jit_stack* jit_callback(void *arg)
590    {
591    return (pcre_jit_stack *)arg;
592    }
593    
594    
595  /*************************************************  /*************************************************
# Line 920  fprintf(outfile, "%.*s", (cb->next_item_ Line 972  fprintf(outfile, "%.*s", (cb->next_item_
972  fprintf(outfile, "\n");  fprintf(outfile, "\n");
973  first_callout = 0;  first_callout = 0;
974    
975    if (cb->mark != last_callout_mark)
976      {
977      fprintf(outfile, "Latest Mark: %s\n",
978        (cb->mark == NULL)? "<unset>" : (char *)(cb->mark));
979      last_callout_mark = cb->mark;
980      }
981    
982  if (cb->callout_data != NULL)  if (cb->callout_data != NULL)
983    {    {
984    int callout_data = *((int *)(cb->callout_data));    int callout_data = *((int *)(cb->callout_data));
# Line 939  return (cb->callout_number != callout_fa Line 998  return (cb->callout_number != callout_fa
998  *            Local malloc functions              *  *            Local malloc functions              *
999  *************************************************/  *************************************************/
1000    
1001  /* Alternative malloc function, to test functionality and show the size of the  /* Alternative malloc function, to test functionality and save the size of a
1002  compiled re. */  compiled re. The show_malloc variable is set only during matching. */
1003    
1004  static void *new_malloc(size_t size)  static void *new_malloc(size_t size)
1005  {  {
# Line 958  if (show_malloc) Line 1017  if (show_malloc)
1017  free(block);  free(block);
1018  }  }
1019    
   
1020  /* For recursion malloc/free, to test stacking calls */  /* For recursion malloc/free, to test stacking calls */
1021    
1022  static void *stack_malloc(size_t size)  static void *stack_malloc(size_t size)
# Line 993  if ((rc = pcre_fullinfo(re, study, optio Line 1051  if ((rc = pcre_fullinfo(re, study, optio
1051    
1052    
1053  /*************************************************  /*************************************************
1054    *      Check for supported JIT architecture      *
1055    *************************************************/
1056    
1057    /* If it won't JIT-compile a very simple regex, return FALSE. */
1058    
1059    static int check_jit_arch(void)
1060    {
1061    const char *error;
1062    int erroffset, rc;
1063    pcre *re = pcre_compile("abc", 0, &error, &erroffset, NULL);
1064    pcre_extra *extra = pcre_study(re, PCRE_STUDY_JIT_COMPILE, &error);
1065    rc = extra != NULL && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 &&
1066      extra->executable_jit != NULL;
1067    pcre_free_study(extra);
1068    free(re);
1069    return rc;
1070    }
1071    
1072    
1073    /*************************************************
1074  *         Byte flipping function                 *  *         Byte flipping function                 *
1075  *************************************************/  *************************************************/
1076    
# Line 1147  printf(" -p use POSIX interface\n Line 1225  printf(" -p use POSIX interface\n
1225  #endif  #endif
1226  printf("  -q       quiet: do not output PCRE version number at start\n");  printf("  -q       quiet: do not output PCRE version number at start\n");
1227  printf("  -S <n>   set stack size to <n> megabytes\n");  printf("  -S <n>   set stack size to <n> megabytes\n");
1228  printf("  -s       output store (memory) used information\n"  printf("  -s       force each pattern to be studied at basic level\n"
1229           "  -s+      force each pattern to be studied, using JIT if available\n"
1230         "  -t       time compilation and execution\n");         "  -t       time compilation and execution\n");
1231  printf("  -t <n>   time compilation and execution, repeating <n> times\n");  printf("  -t <n>   time compilation and execution, repeating <n> times\n");
1232  printf("  -tm      time execution (matching) only\n");  printf("  -tm      time execution (matching) only\n");
# Line 1175  int timeit = 0; Line 1254  int timeit = 0;
1254  int timeitm = 0;  int timeitm = 0;
1255  int showinfo = 0;  int showinfo = 0;
1256  int showstore = 0;  int showstore = 0;
1257    int force_study = -1;
1258    int force_study_options = 0;
1259  int quiet = 0;  int quiet = 0;
1260  int size_offsets = 45;  int size_offsets = 45;
1261  int size_offsets_max;  int size_offsets_max;
# Line 1188  int all_use_dfa = 0; Line 1269  int all_use_dfa = 0;
1269  int yield = 0;  int yield = 0;
1270  int stack_size;  int stack_size;
1271    
1272    pcre_jit_stack *jit_stack = NULL;
1273    
1274    
1275  /* These vectors store, end-to-end, a list of captured substring names. Assume  /* These vectors store, end-to-end, a list of captured substring names. Assume
1276  that 1024 is plenty long enough for the few names we'll be testing. */  that 1024 is plenty long enough for the few names we'll be testing. */
1277    
# Line 1223  while (argc > 1 && argv[op][0] == '-') Line 1307  while (argc > 1 && argv[op][0] == '-')
1307    {    {
1308    unsigned char *endptr;    unsigned char *endptr;
1309    
1310    if (strcmp(argv[op], "-s") == 0 || strcmp(argv[op], "-m") == 0)    if (strcmp(argv[op], "-m") == 0) showstore = 1;
1311      showstore = 1;    else if (strcmp(argv[op], "-s") == 0) force_study = 0;
1312      else if (strcmp(argv[op], "-s+") == 0)
1313        {
1314        force_study = 1;
1315        force_study_options = PCRE_STUDY_JIT_COMPILE;
1316        }
1317    else if (strcmp(argv[op], "-q") == 0) quiet = 1;    else if (strcmp(argv[op], "-q") == 0) quiet = 1;
1318    else if (strcmp(argv[op], "-b") == 0) debug = 1;    else if (strcmp(argv[op], "-b") == 0) debug = 1;
1319    else if (strcmp(argv[op], "-i") == 0) showinfo = 1;    else if (strcmp(argv[op], "-i") == 0) showinfo = 1;
# Line 1258  while (argc > 1 && argv[op][0] == '-') Line 1347  while (argc > 1 && argv[op][0] == '-')
1347        ((stack_size = get_value((unsigned char *)argv[op+1], &endptr)),        ((stack_size = get_value((unsigned char *)argv[op+1], &endptr)),
1348          *endptr == 0))          *endptr == 0))
1349      {      {
1350  #if defined(_WIN32) || defined(WIN32)  #if defined(_WIN32) || defined(WIN32) || defined(__minix)
1351      printf("PCRE: -S not supported on this OS\n");      printf("PCRE: -S not supported on this OS\n");
1352      exit(1);      exit(1);
1353  #else  #else
# Line 1289  while (argc > 1 && argv[op][0] == '-') Line 1378  while (argc > 1 && argv[op][0] == '-')
1378      printf("  %sUTF-8 support\n", rc? "" : "No ");      printf("  %sUTF-8 support\n", rc? "" : "No ");
1379      (void)pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &rc);      (void)pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &rc);
1380      printf("  %sUnicode properties support\n", rc? "" : "No ");      printf("  %sUnicode properties support\n", rc? "" : "No ");
1381        (void)pcre_config(PCRE_CONFIG_JIT, &rc);
1382        if (rc)
1383          printf("  Just-in-time compiler support%s\n", check_jit_arch()?
1384            "" : " (but this architecture is unsupported)");
1385        else
1386          printf("  No just-in-time compiler support\n");
1387      (void)pcre_config(PCRE_CONFIG_NEWLINE, &rc);      (void)pcre_config(PCRE_CONFIG_NEWLINE, &rc);
1388      /* Note that these values are always the ASCII values, even      /* Note that these values are always the ASCII values, even
1389      in EBCDIC environments. CR is 13 and NL is 10. */      in EBCDIC environments. CR is 13 and NL is 10. */
# Line 1394  while (!done) Line 1489  while (!done)
1489    const unsigned char *tables = NULL;    const unsigned char *tables = NULL;
1490    unsigned long int true_size, true_study_size = 0;    unsigned long int true_size, true_study_size = 0;
1491    size_t size, regex_gotten_store;    size_t size, regex_gotten_store;
1492      int do_allcaps = 0;
1493    int do_mark = 0;    int do_mark = 0;
1494    int do_study = 0;    int do_study = 0;
1495      int no_force_study = 0;
1496    int do_debug = debug;    int do_debug = debug;
1497    int do_G = 0;    int do_G = 0;
1498    int do_g = 0;    int do_g = 0;
1499    int do_showinfo = showinfo;    int do_showinfo = showinfo;
1500    int do_showrest = 0;    int do_showrest = 0;
1501      int do_showcaprest = 0;
1502    int do_flip = 0;    int do_flip = 0;
1503    int erroroffset, len, delimiter, poffset;    int erroroffset, len, delimiter, poffset;
1504    
# Line 1462  while (!done) Line 1560  while (!done)
1560          }          }
1561        }        }
1562    
1563      fprintf(outfile, "Compiled regex%s loaded from %s\n",      fprintf(outfile, "Compiled pattern%s loaded from %s\n",
1564        do_flip? " (byte-inverted)" : "", p);        do_flip? " (byte-inverted)" : "", p);
1565    
1566      /* Need to know if UTF-8 for printing data strings */      /* Need to know if UTF-8 for printing data strings */
# Line 1470  while (!done) Line 1568  while (!done)
1568      new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);      new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);
1569      use_utf8 = (get_options & PCRE_UTF8) != 0;      use_utf8 = (get_options & PCRE_UTF8) != 0;
1570    
1571      /* Now see if there is any following study data */      /* Now see if there is any following study data. */
1572    
1573      if (true_study_size != 0)      if (true_study_size != 0)
1574        {        {
# Line 1486  while (!done) Line 1584  while (!done)
1584          {          {
1585          FAIL_READ:          FAIL_READ:
1586          fprintf(outfile, "Failed to read data from %s\n", p);          fprintf(outfile, "Failed to read data from %s\n", p);
1587          if (extra != NULL) new_free(extra);          if (extra != NULL) pcre_free_study(extra);
1588          if (re != NULL) new_free(re);          if (re != NULL) new_free(re);
1589          fclose(f);          fclose(f);
1590          continue;          continue;
# Line 1552  while (!done) Line 1650  while (!done)
1650    /* Look for options after final delimiter */    /* Look for options after final delimiter */
1651    
1652    options = 0;    options = 0;
   study_options = 0;  
1653    log_store = showstore;  /* default from command line */    log_store = showstore;  /* default from command line */
1654    
1655    while (*pp != 0)    while (*pp != 0)
# Line 1566  while (!done) Line 1663  while (!done)
1663        case 's': options |= PCRE_DOTALL; break;        case 's': options |= PCRE_DOTALL; break;
1664        case 'x': options |= PCRE_EXTENDED; break;        case 'x': options |= PCRE_EXTENDED; break;
1665    
1666        case '+': do_showrest = 1; break;        case '+':
1667          if (do_showrest) do_showcaprest = 1; else do_showrest = 1;
1668          break;
1669    
1670          case '=': do_allcaps = 1; break;
1671        case 'A': options |= PCRE_ANCHORED; break;        case 'A': options |= PCRE_ANCHORED; break;
1672        case 'B': do_debug = 1; break;        case 'B': do_debug = 1; break;
1673        case 'C': options |= PCRE_AUTO_CALLOUT; break;        case 'C': options |= PCRE_AUTO_CALLOUT; break;
# Line 1584  while (!done) Line 1685  while (!done)
1685        case 'P': do_posix = 1; break;        case 'P': do_posix = 1; break;
1686  #endif  #endif
1687    
1688        case 'S': do_study = 1; break;        case 'S':
1689          if (do_study == 0)
1690            {
1691            do_study = 1;
1692            if (*pp == '+')
1693              {
1694              study_options |= PCRE_STUDY_JIT_COMPILE;
1695              pp++;
1696              }
1697            }
1698          else
1699            {
1700            do_study = 0;
1701            no_force_study = 1;
1702            }
1703          break;
1704    
1705        case 'U': options |= PCRE_UNGREEDY; break;        case 'U': options |= PCRE_UNGREEDY; break;
1706        case 'W': options |= PCRE_UCP; break;        case 'W': options |= PCRE_UCP; break;
1707        case 'X': options |= PCRE_EXTRA; break;        case 'X': options |= PCRE_EXTRA; break;
1708          case 'Y': options |= PCRE_NO_START_OPTIMISE; break;
1709        case 'Z': debug_lengths = 0; break;        case 'Z': debug_lengths = 0; break;
1710        case '8': options |= PCRE_UTF8; use_utf8 = 1; break;        case '8': options |= PCRE_UTF8; use_utf8 = 1; break;
1711        case '?': options |= PCRE_NO_UTF8_CHECK; break;        case '?': options |= PCRE_NO_UTF8_CHECK; break;
# Line 1767  while (!done) Line 1885  while (!done)
1885      true_size = ((real_pcre *)re)->size;      true_size = ((real_pcre *)re)->size;
1886      regex_gotten_store = gotten_store;      regex_gotten_store = gotten_store;
1887    
1888      /* If /S was present, study the regexp to generate additional info to      /* If -s or /S was present, study the regex to generate additional info to
1889      help with the matching. */      help with the matching, unless the pattern has the SS option, which
1890        suppresses the effect of /S (used for a few test patterns where studying is
1891        never sensible). */
1892    
1893      if (do_study)      if (do_study || (force_study >= 0 && !no_force_study))
1894        {        {
1895        if (timeit > 0)        if (timeit > 0)
1896          {          {
# Line 1778  while (!done) Line 1898  while (!done)
1898          clock_t time_taken;          clock_t time_taken;
1899          clock_t start_time = clock();          clock_t start_time = clock();
1900          for (i = 0; i < timeit; i++)          for (i = 0; i < timeit; i++)
1901            extra = pcre_study(re, study_options, &error);            extra = pcre_study(re, study_options | force_study_options, &error);
1902          time_taken = clock() - start_time;          time_taken = clock() - start_time;
1903          if (extra != NULL) free(extra);          if (extra != NULL) pcre_free_study(extra);
1904          fprintf(outfile, "  Study time %.4f milliseconds\n",          fprintf(outfile, "  Study time %.4f milliseconds\n",
1905            (((double)time_taken * 1000.0) / (double)timeit) /            (((double)time_taken * 1000.0) / (double)timeit) /
1906              (double)CLOCKS_PER_SEC);              (double)CLOCKS_PER_SEC);
1907          }          }
1908        extra = pcre_study(re, study_options, &error);        extra = pcre_study(re, study_options | force_study_options, &error);
1909        if (error != NULL)        if (error != NULL)
1910          fprintf(outfile, "Failed to study: %s\n", error);          fprintf(outfile, "Failed to study: %s\n", error);
1911        else if (extra != NULL)        else if (extra != NULL)
# Line 1924  while (!done) Line 2044  while (!done)
2044        if (do_flip) all_options = byteflip(all_options, sizeof(all_options));        if (do_flip) all_options = byteflip(all_options, sizeof(all_options));
2045    
2046        if (get_options == 0) fprintf(outfile, "No options\n");        if (get_options == 0) fprintf(outfile, "No options\n");
2047          else fprintf(outfile, "Options:%s%s%s%s%s%s%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%s%s%s%s%s%s\n",
2048            ((get_options & PCRE_ANCHORED) != 0)? " anchored" : "",            ((get_options & PCRE_ANCHORED) != 0)? " anchored" : "",
2049            ((get_options & PCRE_CASELESS) != 0)? " caseless" : "",            ((get_options & PCRE_CASELESS) != 0)? " caseless" : "",
2050            ((get_options & PCRE_EXTENDED) != 0)? " extended" : "",            ((get_options & PCRE_EXTENDED) != 0)? " extended" : "",
# Line 1940  while (!done) Line 2060  while (!done)
2060            ((get_options & PCRE_UTF8) != 0)? " utf8" : "",            ((get_options & PCRE_UTF8) != 0)? " utf8" : "",
2061            ((get_options & PCRE_UCP) != 0)? " ucp" : "",            ((get_options & PCRE_UCP) != 0)? " ucp" : "",
2062            ((get_options & PCRE_NO_UTF8_CHECK) != 0)? " no_utf8_check" : "",            ((get_options & PCRE_NO_UTF8_CHECK) != 0)? " no_utf8_check" : "",
2063              ((get_options & PCRE_NO_START_OPTIMIZE) != 0)? " no_start_optimize" : "",
2064            ((get_options & PCRE_DUPNAMES) != 0)? " dupnames" : "");            ((get_options & PCRE_DUPNAMES) != 0)? " dupnames" : "");
2065    
2066        if (jchanged) fprintf(outfile, "Duplicate name status changes\n");        if (jchanged) fprintf(outfile, "Duplicate name status changes\n");
# Line 2007  while (!done) Line 2128  while (!done)
2128        /* Don't output study size; at present it is in any case a fixed        /* Don't output study size; at present it is in any case a fixed
2129        value, but it varies, depending on the computer architecture, and        value, but it varies, depending on the computer architecture, and
2130        so messes up the test suite. (And with the /F option, it might be        so messes up the test suite. (And with the /F option, it might be
2131        flipped.) */        flipped.) If study was forced by an external -s, don't show this
2132          information unless -i or -d was also present. This means that, except
2133          when auto-callouts are involved, the output from runs with and without
2134          -s should be identical. */
2135    
2136        if (do_study)        if (do_study || (force_study >= 0 && showinfo && !no_force_study))
2137          {          {
2138          if (extra == NULL)          if (extra == NULL)
2139            fprintf(outfile, "Study returned NULL\n");            fprintf(outfile, "Study returned NULL\n");
# Line 2053  while (!done) Line 2177  while (!done)
2177              fprintf(outfile, "\n");              fprintf(outfile, "\n");
2178              }              }
2179            }            }
2180    
2181            /* Show this only if the JIT was set by /S, not by -s. */
2182    
2183            if ((study_options & PCRE_STUDY_JIT_COMPILE) != 0)
2184              {
2185              int jit;
2186              new_info(re, extra, PCRE_INFO_JIT, &jit);
2187              if (jit)
2188                fprintf(outfile, "JIT study was successful\n");
2189              else
2190    #ifdef SUPPORT_JIT
2191                fprintf(outfile, "JIT study was not successful\n");
2192    #else
2193                fprintf(outfile, "JIT support is not available in this version of PCRE\n");
2194    #endif
2195              }
2196          }          }
2197        }        }
2198    
# Line 2087  while (!done) Line 2227  while (!done)
2227            }            }
2228          else          else
2229            {            {
2230            fprintf(outfile, "Compiled regex written to %s\n", to_file);            fprintf(outfile, "Compiled pattern written to %s\n", to_file);
2231    
2232              /* If there is study data, write it. */
2233    
2234            if (extra != NULL)            if (extra != NULL)
2235              {              {
2236              if (fwrite(extra->study_data, 1, true_study_size, f) <              if (fwrite(extra->study_data, 1, true_study_size, f) <
# Line 2097  while (!done) Line 2240  while (!done)
2240                  strerror(errno));                  strerror(errno));
2241                }                }
2242              else fprintf(outfile, "Study data written to %s\n", to_file);              else fprintf(outfile, "Study data written to %s\n", to_file);
   
2243              }              }
2244            }            }
2245          fclose(f);          fclose(f);
2246          }          }
2247    
2248        new_free(re);        new_free(re);
2249        if (extra != NULL) new_free(extra);        if (extra != NULL) pcre_free_study(extra);
2250        if (locale_set)        if (locale_set)
2251          {          {
2252          new_free((void *)tables);          new_free((void *)tables);
# Line 2132  while (!done) Line 2274  while (!done)
2274      int getlist = 0;      int getlist = 0;
2275      int gmatched = 0;      int gmatched = 0;
2276      int start_offset = 0;      int start_offset = 0;
2277        int start_offset_sign = 1;
2278      int g_notempty = 0;      int g_notempty = 0;
2279      int use_dfa = 0;      int use_dfa = 0;
2280    
# Line 2145  while (!done) Line 2288  while (!done)
2288    
2289      pcre_callout = callout;      pcre_callout = callout;
2290      first_callout = 1;      first_callout = 1;
2291        last_callout_mark = NULL;
2292      callout_extra = 0;      callout_extra = 0;
2293      callout_count = 0;      callout_count = 0;
2294      callout_fail_count = 999999;      callout_fail_count = 999999;
# Line 2264  while (!done) Line 2408  while (!done)
2408          continue;          continue;
2409    
2410          case '>':          case '>':
2411            if (*p == '-')
2412              {
2413              start_offset_sign = -1;
2414              p++;
2415              }
2416          while(isdigit(*p)) start_offset = start_offset * 10 + *p++ - '0';          while(isdigit(*p)) start_offset = start_offset * 10 + *p++ - '0';
2417            start_offset *= start_offset_sign;
2418          continue;          continue;
2419    
2420          case 'A':  /* Option setting */          case 'A':  /* Option setting */
# Line 2363  while (!done) Line 2513  while (!done)
2513            getnamesptr = npp;            getnamesptr = npp;
2514            }            }
2515          continue;          continue;
2516    
2517            case 'J':
2518            while(isdigit(*p)) n = n * 10 + *p++ - '0';
2519            if (extra != NULL
2520                && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0
2521                && extra->executable_jit != NULL)
2522              {
2523              if (jit_stack != NULL) pcre_jit_stack_free(jit_stack);
2524              jit_stack = pcre_jit_stack_alloc(1, n * 1024);
2525              pcre_assign_jit_stack(extra, jit_callback, jit_stack);
2526              }
2527            continue;
2528    
2529          case 'L':          case 'L':
2530          getlist = 1;          getlist = 1;
# Line 2522  while (!done) Line 2684  while (!done)
2684              (void)pchars(dbuffer + pmatch[i].rm_so,              (void)pchars(dbuffer + pmatch[i].rm_so,
2685                pmatch[i].rm_eo - pmatch[i].rm_so, outfile);                pmatch[i].rm_eo - pmatch[i].rm_so, outfile);
2686              fprintf(outfile, "\n");              fprintf(outfile, "\n");
2687              if (i == 0 && do_showrest)              if (do_showcaprest || (i == 0 && do_showrest))
2688                {                {
2689                fprintf(outfile, " 0+ ");                fprintf(outfile, "%2d+ ", (int)i);
2690                (void)pchars(dbuffer + pmatch[i].rm_eo, len - pmatch[i].rm_eo,                (void)pchars(dbuffer + pmatch[i].rm_eo, len - pmatch[i].rm_eo,
2691                  outfile);                  outfile);
2692                fprintf(outfile, "\n");                fprintf(outfile, "\n");
# Line 2574  while (!done) Line 2736  while (!done)
2736    
2737        /* If find_match_limit is set, we want to do repeated matches with        /* If find_match_limit is set, we want to do repeated matches with
2738        varying limits in order to find the minimum value for the match limit and        varying limits in order to find the minimum value for the match limit and
2739        for the recursion limit. */        for the recursion limit. The match limits are relevant only to the normal
2740          running of pcre_exec(), so disable the JIT optimization. This makes it
2741          possible to run the same set of tests with and without JIT externally
2742          requested. */
2743    
2744        if (find_match_limit)        if (find_match_limit)
2745          {          {
# Line 2583  while (!done) Line 2748  while (!done)
2748            extra = (pcre_extra *)malloc(sizeof(pcre_extra));            extra = (pcre_extra *)malloc(sizeof(pcre_extra));
2749            extra->flags = 0;            extra->flags = 0;
2750            }            }
2751            else extra->flags &= ~PCRE_EXTRA_EXECUTABLE_JIT;
2752    
2753          (void)check_match_limit(re, extra, bptr, len, start_offset,          (void)check_match_limit(re, extra, bptr, len, start_offset,
2754            options|g_notempty, use_offsets, use_size_offsets,            options|g_notempty, use_offsets, use_size_offsets,
2755            PCRE_EXTRA_MATCH_LIMIT, &(extra->match_limit),            PCRE_EXTRA_MATCH_LIMIT, &(extra->match_limit),
# Line 2666  while (!done) Line 2832  while (!done)
2832              }              }
2833            }            }
2834    
2835            /* do_allcaps requests showing of all captures in the pattern, to check
2836            unset ones at the end. */
2837    
2838            if (do_allcaps)
2839              {
2840              new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count);
2841              count++;   /* Allow for full match */
2842              if (count * 2 > use_size_offsets) count = use_size_offsets/2;
2843              }
2844    
2845            /* Output the captured substrings */
2846    
2847          for (i = 0; i < count * 2; i += 2)          for (i = 0; i < count * 2; i += 2)
2848            {            {
2849            if (use_offsets[i] < 0)            if (use_offsets[i] < 0)
2850                {
2851                if (use_offsets[i] != -1)
2852                  fprintf(outfile, "ERROR: bad negative value %d for offset %d\n",
2853                    use_offsets[i], i);
2854                if (use_offsets[i+1] != -1)
2855                  fprintf(outfile, "ERROR: bad negative value %d for offset %d\n",
2856                    use_offsets[i+1], i+1);
2857              fprintf(outfile, "%2d: <unset>\n", i/2);              fprintf(outfile, "%2d: <unset>\n", i/2);
2858                }
2859            else            else
2860              {              {
2861              fprintf(outfile, "%2d: ", i/2);              fprintf(outfile, "%2d: ", i/2);
2862              (void)pchars(bptr + use_offsets[i],              (void)pchars(bptr + use_offsets[i],
2863                use_offsets[i+1] - use_offsets[i], outfile);                use_offsets[i+1] - use_offsets[i], outfile);
2864              fprintf(outfile, "\n");              fprintf(outfile, "\n");
2865              if (i == 0)              if (do_showcaprest || (i == 0 && do_showrest))
2866                {                {
2867                if (do_showrest)                fprintf(outfile, "%2d+ ", i/2);
2868                  {                (void)pchars(bptr + use_offsets[i+1], len - use_offsets[i+1],
2869                  fprintf(outfile, " 0+ ");                  outfile);
2870                  (void)pchars(bptr + use_offsets[i+1], len - use_offsets[i+1],                fprintf(outfile, "\n");
                   outfile);  
                 fprintf(outfile, "\n");  
                 }  
2871                }                }
2872              }              }
2873            }            }
# Line 2764  while (!done) Line 2947  while (!done)
2947                fprintf(outfile, "%2dL %s\n", i, stringlist[i]);                fprintf(outfile, "%2dL %s\n", i, stringlist[i]);
2948              if (stringlist[i] != NULL)              if (stringlist[i] != NULL)
2949                fprintf(outfile, "string list not terminated by NULL\n");                fprintf(outfile, "string list not terminated by NULL\n");
             /* free((void *)stringlist); */  
2950              pcre_free_substring_list(stringlist);              pcre_free_substring_list(stringlist);
2951              }              }
2952            }            }
# Line 2791  while (!done) Line 2973  while (!done)
2973        to advance the start offset, and continue. We won't be at the end of the        to advance the start offset, and continue. We won't be at the end of the
2974        string - that was checked before setting g_notempty.        string - that was checked before setting g_notempty.
2975    
2976        Complication arises in the case when the newline option is "any" or        Complication arises in the case when the newline convention is "any",
2977        "anycrlf". If the previous match was at the end of a line terminated by        "crlf", or "anycrlf". If the previous match was at the end of a line
2978        CRLF, an advance of one character just passes the \r, whereas we should        terminated by CRLF, an advance of one character just passes the \r,
2979        prefer the longer newline sequence, as does the code in pcre_exec().        whereas we should prefer the longer newline sequence, as does the code in
2980        Fudge the offset value to achieve this.        pcre_exec(). Fudge the offset value to achieve this. We check for a
2981          newline setting in the pattern; if none was set, use pcre_config() to
2982          find the default.
2983    
2984        Otherwise, in the case of UTF-8 matching, the advance must be one        Otherwise, in the case of UTF-8 matching, the advance must be one
2985        character, not one byte. */        character, not one byte. */
# Line 2820  while (!done) Line 3004  while (!done)
3004                      (d == -1)? PCRE_NEWLINE_ANY : 0;                      (d == -1)? PCRE_NEWLINE_ANY : 0;
3005              }              }
3006            if (((obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANY ||            if (((obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANY ||
3007                   (obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_CRLF ||
3008                 (obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANYCRLF)                 (obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANYCRLF)
3009                &&                &&
3010                start_offset < len - 1 &&                start_offset < len - 1 &&
# Line 2830  while (!done) Line 3015  while (!done)
3015              {              {
3016              while (start_offset + onechar < len)              while (start_offset + onechar < len)
3017                {                {
3018                int tb = bptr[start_offset+onechar];                if ((bptr[start_offset+onechar] & 0xc0) != 0x80) break;
3019                if (tb <= 127) break;                onechar++;
               tb &= 0xc0;  
               if (tb != 0 && tb != 0xc0) onechar++;  
3020                }                }
3021              }              }
3022            use_offsets[1] = start_offset + onechar;            use_offsets[1] = start_offset + onechar;
3023            }            }
3024          else          else
3025            {            {
3026            if (count == PCRE_ERROR_NOMATCH)            switch(count)
3027              {              {
3028                case PCRE_ERROR_NOMATCH:
3029              if (gmatched == 0)              if (gmatched == 0)
3030                {                {
3031                if (markptr == NULL) fprintf(outfile, "No match\n");                if (markptr == NULL) fprintf(outfile, "No match\n");
3032                  else fprintf(outfile, "No match, mark = %s\n", markptr);                  else fprintf(outfile, "No match, mark = %s\n", markptr);
3033                }                }
3034                break;
3035    
3036                case PCRE_ERROR_BADUTF8:
3037                case PCRE_ERROR_SHORTUTF8:
3038                fprintf(outfile, "Error %d (%s UTF-8 string)", count,
3039                  (count == PCRE_ERROR_BADUTF8)? "bad" : "short");
3040                if (use_size_offsets >= 2)
3041                  fprintf(outfile, " offset=%d reason=%d", use_offsets[0],
3042                    use_offsets[1]);
3043                fprintf(outfile, "\n");
3044                break;
3045    
3046                default:
3047                if (count < 0 && (-count) < sizeof(errtexts)/sizeof(const char *))
3048                  fprintf(outfile, "Error %d (%s)\n", count, errtexts[-count]);
3049                else
3050                  fprintf(outfile, "Error %d (Unexpected value)\n", count);
3051                break;
3052              }              }
3053            else fprintf(outfile, "Error %d\n", count);  
3054            break;  /* Out of the /g loop */            break;  /* Out of the /g loop */
3055            }            }
3056          }          }
# Line 2895  while (!done) Line 3097  while (!done)
3097  #endif  #endif
3098    
3099    if (re != NULL) new_free(re);    if (re != NULL) new_free(re);
3100    if (extra != NULL) new_free(extra);    if (extra != NULL) pcre_free_study(extra);
3101    if (locale_set)    if (locale_set)
3102      {      {
3103      new_free((void *)tables);      new_free((void *)tables);
3104      setlocale(LC_CTYPE, "C");      setlocale(LC_CTYPE, "C");
3105      locale_set = 0;      locale_set = 0;
3106      }      }
3107      if (jit_stack != NULL)
3108        {
3109        pcre_jit_stack_free(jit_stack);
3110        jit_stack = NULL;
3111        }
3112    }    }
3113    
3114  if (infile == stdin) fprintf(outfile, "\n");  if (infile == stdin) fprintf(outfile, "\n");

Legend:
Removed from v.558  
changed lines
  Added in v.676

webmaster@exim.org
ViewVC Help
Powered by ViewVC 1.1.12