/[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 541 by ph10, Mon Jun 14 15:19:33 2010 UTC revision 675 by ph10, Sat Aug 27 10:18:46 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    };
234    
235    
236  /*************************************************  /*************************************************
237  *         Alternate character tables             *  *         Alternate character tables             *
238  *************************************************/  *************************************************/
239    
240  /* By default, the "tables" pointer when calling PCRE is set to NULL, thereby  /* By default, the "tables" pointer when calling PCRE is set to NULL, thereby
241  using the default tables of the library. However, the T option can be used to  using the default tables of the library. However, the T option can be used to
242  select alternate sets of tables, for different kinds of testing. Note also that  select alternate sets of tables, for different kinds of testing. Note also that
243  the L (locale) option also adjusts the tables. */  the L (locale) option also adjusts the tables. */
244    
245  /* This is the set of tables distributed as default with PCRE. It recognizes  /* This is the set of tables distributed as default with PCRE. It recognizes
246  only ASCII characters. */  only ASCII characters. */
247    
248  static const unsigned char tables0[] = {  static const unsigned char tables0[] = {
# Line 371  graph, print, punct, and cntrl. Other cl Line 414  graph, print, punct, and cntrl. Other cl
414    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
415    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
416    
417  /* This is a set of tables that came orginally from a Windows user. It seems to  /* This is a set of tables that came orginally from a Windows user. It seems to
418  be at least an approximation of ISO 8859. In particular, there are characters  be at least an approximation of ISO 8859. In particular, there are characters
419  greater than 128 that are marked as spaces, letters, etc. */  greater than 128 that are marked as spaces, letters, etc. */
420    
421  static const unsigned char tables1[] = {  static const unsigned char tables1[] = {
# Line 516  static const unsigned char tables1[] = { Line 559  static const unsigned char tables1[] = {
559    
560    
561    
562    
563    #ifndef HAVE_STRERROR
564    /*************************************************
565    *     Provide strerror() for non-ANSI libraries  *
566    *************************************************/
567    
568    /* Some old-fashioned systems still around (e.g. SunOS4) don't have strerror()
569    in their libraries, but can provide the same facility by this simple
570    alternative function. */
571    
572    extern int   sys_nerr;
573    extern char *sys_errlist[];
574    
575    char *
576    strerror(int n)
577    {
578    if (n < 0 || n >= sys_nerr) return "unknown error number";
579    return sys_errlist[n];
580    }
581    #endif /* HAVE_STRERROR */
582    
583    
584    /*************************************************
585    *         JIT memory callback                    *
586    *************************************************/
587    
588    static pcre_jit_stack* jit_callback(void *arg)
589    {
590    return (pcre_jit_stack *)arg;
591    }
592    
593    
594  /*************************************************  /*************************************************
595  *        Read or extend an input line            *  *        Read or extend an input line            *
596  *************************************************/  *************************************************/
# Line 896  fprintf(outfile, "%.*s", (cb->next_item_ Line 971  fprintf(outfile, "%.*s", (cb->next_item_
971  fprintf(outfile, "\n");  fprintf(outfile, "\n");
972  first_callout = 0;  first_callout = 0;
973    
974    if (cb->mark != last_callout_mark)
975      {
976      fprintf(outfile, "Latest Mark: %s\n",
977        (cb->mark == NULL)? "<unset>" : (char *)(cb->mark));
978      last_callout_mark = cb->mark;
979      }
980    
981  if (cb->callout_data != NULL)  if (cb->callout_data != NULL)
982    {    {
983    int callout_data = *((int *)(cb->callout_data));    int callout_data = *((int *)(cb->callout_data));
# Line 915  return (cb->callout_number != callout_fa Line 997  return (cb->callout_number != callout_fa
997  *            Local malloc functions              *  *            Local malloc functions              *
998  *************************************************/  *************************************************/
999    
1000  /* Alternative malloc function, to test functionality and show the size of the  /* Alternative malloc function, to test functionality and save the size of a
1001  compiled re. */  compiled re. The show_malloc variable is set only during matching. */
1002    
1003  static void *new_malloc(size_t size)  static void *new_malloc(size_t size)
1004  {  {
# Line 934  if (show_malloc) Line 1016  if (show_malloc)
1016  free(block);  free(block);
1017  }  }
1018    
   
1019  /* For recursion malloc/free, to test stacking calls */  /* For recursion malloc/free, to test stacking calls */
1020    
1021  static void *stack_malloc(size_t size)  static void *stack_malloc(size_t size)
# Line 969  if ((rc = pcre_fullinfo(re, study, optio Line 1050  if ((rc = pcre_fullinfo(re, study, optio
1050    
1051    
1052  /*************************************************  /*************************************************
1053    *      Check for supported JIT architecture      *
1054    *************************************************/
1055    
1056    /* If it won't JIT-compile a very simple regex, return FALSE. */
1057    
1058    static int check_jit_arch(void)
1059    {
1060    const char *error;
1061    int erroffset, rc;
1062    pcre *re = pcre_compile("abc", 0, &error, &erroffset, NULL);
1063    pcre_extra *extra = pcre_study(re, PCRE_STUDY_JIT_COMPILE, &error);
1064    rc = extra != NULL && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 &&
1065      extra->executable_jit != NULL;
1066    pcre_free_study(extra);
1067    free(re);
1068    return rc;
1069    }
1070    
1071    
1072    /*************************************************
1073  *         Byte flipping function                 *  *         Byte flipping function                 *
1074  *************************************************/  *************************************************/
1075    
# Line 1123  printf(" -p use POSIX interface\n Line 1224  printf(" -p use POSIX interface\n
1224  #endif  #endif
1225  printf("  -q       quiet: do not output PCRE version number at start\n");  printf("  -q       quiet: do not output PCRE version number at start\n");
1226  printf("  -S <n>   set stack size to <n> megabytes\n");  printf("  -S <n>   set stack size to <n> megabytes\n");
1227  printf("  -s       output store (memory) used information\n"  printf("  -s       force each pattern to be studied at basic level\n"
1228           "  -s+      force each pattern to be studied, using JIT if available\n"
1229         "  -t       time compilation and execution\n");         "  -t       time compilation and execution\n");
1230  printf("  -t <n>   time compilation and execution, repeating <n> times\n");  printf("  -t <n>   time compilation and execution, repeating <n> times\n");
1231  printf("  -tm      time execution (matching) only\n");  printf("  -tm      time execution (matching) only\n");
# Line 1151  int timeit = 0; Line 1253  int timeit = 0;
1253  int timeitm = 0;  int timeitm = 0;
1254  int showinfo = 0;  int showinfo = 0;
1255  int showstore = 0;  int showstore = 0;
1256    int force_study = -1;
1257    int force_study_options = 0;
1258  int quiet = 0;  int quiet = 0;
1259  int size_offsets = 45;  int size_offsets = 45;
1260  int size_offsets_max;  int size_offsets_max;
# Line 1164  int all_use_dfa = 0; Line 1268  int all_use_dfa = 0;
1268  int yield = 0;  int yield = 0;
1269  int stack_size;  int stack_size;
1270    
1271    pcre_jit_stack *jit_stack = NULL;
1272    
1273    
1274  /* 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
1275  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. */
1276    
# Line 1199  while (argc > 1 && argv[op][0] == '-') Line 1306  while (argc > 1 && argv[op][0] == '-')
1306    {    {
1307    unsigned char *endptr;    unsigned char *endptr;
1308    
1309    if (strcmp(argv[op], "-s") == 0 || strcmp(argv[op], "-m") == 0)    if (strcmp(argv[op], "-m") == 0) showstore = 1;
1310      showstore = 1;    else if (strcmp(argv[op], "-s") == 0) force_study = 0;
1311      else if (strcmp(argv[op], "-s+") == 0)
1312        {
1313        force_study = 1;
1314        force_study_options = PCRE_STUDY_JIT_COMPILE;
1315        }
1316    else if (strcmp(argv[op], "-q") == 0) quiet = 1;    else if (strcmp(argv[op], "-q") == 0) quiet = 1;
1317    else if (strcmp(argv[op], "-b") == 0) debug = 1;    else if (strcmp(argv[op], "-b") == 0) debug = 1;
1318    else if (strcmp(argv[op], "-i") == 0) showinfo = 1;    else if (strcmp(argv[op], "-i") == 0) showinfo = 1;
# Line 1234  while (argc > 1 && argv[op][0] == '-') Line 1346  while (argc > 1 && argv[op][0] == '-')
1346        ((stack_size = get_value((unsigned char *)argv[op+1], &endptr)),        ((stack_size = get_value((unsigned char *)argv[op+1], &endptr)),
1347          *endptr == 0))          *endptr == 0))
1348      {      {
1349  #if defined(_WIN32) || defined(WIN32)  #if defined(_WIN32) || defined(WIN32) || defined(__minix)
1350      printf("PCRE: -S not supported on this OS\n");      printf("PCRE: -S not supported on this OS\n");
1351      exit(1);      exit(1);
1352  #else  #else
# Line 1265  while (argc > 1 && argv[op][0] == '-') Line 1377  while (argc > 1 && argv[op][0] == '-')
1377      printf("  %sUTF-8 support\n", rc? "" : "No ");      printf("  %sUTF-8 support\n", rc? "" : "No ");
1378      (void)pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &rc);      (void)pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &rc);
1379      printf("  %sUnicode properties support\n", rc? "" : "No ");      printf("  %sUnicode properties support\n", rc? "" : "No ");
1380        (void)pcre_config(PCRE_CONFIG_JIT, &rc);
1381        if (rc)
1382          printf("  Just-in-time compiler support%s\n", check_jit_arch()?
1383            "" : " (but this architecture is unsupported)");
1384        else
1385          printf("  No just-in-time compiler support\n");
1386      (void)pcre_config(PCRE_CONFIG_NEWLINE, &rc);      (void)pcre_config(PCRE_CONFIG_NEWLINE, &rc);
1387      /* Note that these values are always the ASCII values, even      /* Note that these values are always the ASCII values, even
1388      in EBCDIC environments. CR is 13 and NL is 10. */      in EBCDIC environments. CR is 13 and NL is 10. */
# Line 1370  while (!done) Line 1488  while (!done)
1488    const unsigned char *tables = NULL;    const unsigned char *tables = NULL;
1489    unsigned long int true_size, true_study_size = 0;    unsigned long int true_size, true_study_size = 0;
1490    size_t size, regex_gotten_store;    size_t size, regex_gotten_store;
1491      int do_allcaps = 0;
1492    int do_mark = 0;    int do_mark = 0;
1493    int do_study = 0;    int do_study = 0;
1494      int no_force_study = 0;
1495    int do_debug = debug;    int do_debug = debug;
1496    int do_G = 0;    int do_G = 0;
1497    int do_g = 0;    int do_g = 0;
1498    int do_showinfo = showinfo;    int do_showinfo = showinfo;
1499    int do_showrest = 0;    int do_showrest = 0;
1500      int do_showcaprest = 0;
1501    int do_flip = 0;    int do_flip = 0;
1502    int erroroffset, len, delimiter, poffset;    int erroroffset, len, delimiter, poffset;
1503    
# Line 1438  while (!done) Line 1559  while (!done)
1559          }          }
1560        }        }
1561    
1562      fprintf(outfile, "Compiled regex%s loaded from %s\n",      fprintf(outfile, "Compiled pattern%s loaded from %s\n",
1563        do_flip? " (byte-inverted)" : "", p);        do_flip? " (byte-inverted)" : "", p);
1564    
1565      /* Need to know if UTF-8 for printing data strings */      /* Need to know if UTF-8 for printing data strings */
# Line 1446  while (!done) Line 1567  while (!done)
1567      new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);      new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);
1568      use_utf8 = (get_options & PCRE_UTF8) != 0;      use_utf8 = (get_options & PCRE_UTF8) != 0;
1569    
1570      /* Now see if there is any following study data */      /* Now see if there is any following study data. */
1571    
1572      if (true_study_size != 0)      if (true_study_size != 0)
1573        {        {
# Line 1462  while (!done) Line 1583  while (!done)
1583          {          {
1584          FAIL_READ:          FAIL_READ:
1585          fprintf(outfile, "Failed to read data from %s\n", p);          fprintf(outfile, "Failed to read data from %s\n", p);
1586          if (extra != NULL) new_free(extra);          if (extra != NULL) pcre_free_study(extra);
1587          if (re != NULL) new_free(re);          if (re != NULL) new_free(re);
1588          fclose(f);          fclose(f);
1589          continue;          continue;
# Line 1528  while (!done) Line 1649  while (!done)
1649    /* Look for options after final delimiter */    /* Look for options after final delimiter */
1650    
1651    options = 0;    options = 0;
   study_options = 0;  
1652    log_store = showstore;  /* default from command line */    log_store = showstore;  /* default from command line */
1653    
1654    while (*pp != 0)    while (*pp != 0)
# Line 1542  while (!done) Line 1662  while (!done)
1662        case 's': options |= PCRE_DOTALL; break;        case 's': options |= PCRE_DOTALL; break;
1663        case 'x': options |= PCRE_EXTENDED; break;        case 'x': options |= PCRE_EXTENDED; break;
1664    
1665        case '+': do_showrest = 1; break;        case '+':
1666          if (do_showrest) do_showcaprest = 1; else do_showrest = 1;
1667          break;
1668    
1669          case '=': do_allcaps = 1; break;
1670        case 'A': options |= PCRE_ANCHORED; break;        case 'A': options |= PCRE_ANCHORED; break;
1671        case 'B': do_debug = 1; break;        case 'B': do_debug = 1; break;
1672        case 'C': options |= PCRE_AUTO_CALLOUT; break;        case 'C': options |= PCRE_AUTO_CALLOUT; break;
# Line 1560  while (!done) Line 1684  while (!done)
1684        case 'P': do_posix = 1; break;        case 'P': do_posix = 1; break;
1685  #endif  #endif
1686    
1687        case 'S': do_study = 1; break;        case 'S':
1688          if (do_study == 0)
1689            {
1690            do_study = 1;
1691            if (*pp == '+')
1692              {
1693              study_options |= PCRE_STUDY_JIT_COMPILE;
1694              pp++;
1695              }
1696            }
1697          else
1698            {
1699            do_study = 0;
1700            no_force_study = 1;
1701            }
1702          break;
1703    
1704        case 'U': options |= PCRE_UNGREEDY; break;        case 'U': options |= PCRE_UNGREEDY; break;
1705        case 'W': options |= PCRE_UCP; break;        case 'W': options |= PCRE_UCP; break;
1706        case 'X': options |= PCRE_EXTRA; break;        case 'X': options |= PCRE_EXTRA; break;
1707          case 'Y': options |= PCRE_NO_START_OPTIMISE; break;
1708        case 'Z': debug_lengths = 0; break;        case 'Z': debug_lengths = 0; break;
1709        case '8': options |= PCRE_UTF8; use_utf8 = 1; break;        case '8': options |= PCRE_UTF8; use_utf8 = 1; break;
1710        case '?': options |= PCRE_NO_UTF8_CHECK; break;        case '?': options |= PCRE_NO_UTF8_CHECK; break;
1711    
1712        case 'T':        case 'T':
1713        switch (*pp++)        switch (*pp++)
1714          {          {
1715          case '0': tables = tables0; break;          case '0': tables = tables0; break;
1716          case '1': tables = tables1; break;          case '1': tables = tables1; break;
1717    
1718          case '\r':          case '\r':
1719          case '\n':          case '\n':
1720          case ' ':          case ' ':
1721          case 0:          case 0:
1722          fprintf(outfile, "** Missing table number after /T\n");          fprintf(outfile, "** Missing table number after /T\n");
1723          goto SKIP_DATA;          goto SKIP_DATA;
1724    
1725          default:          default:
1726          fprintf(outfile, "** Bad table number \"%c\" after /T\n", pp[-1]);          fprintf(outfile, "** Bad table number \"%c\" after /T\n", pp[-1]);
1727          goto SKIP_DATA;          goto SKIP_DATA;
1728          }          }
1729        break;        break;
1730    
1731        case 'L':        case 'L':
1732        ppp = pp;        ppp = pp;
# Line 1743  while (!done) Line 1884  while (!done)
1884      true_size = ((real_pcre *)re)->size;      true_size = ((real_pcre *)re)->size;
1885      regex_gotten_store = gotten_store;      regex_gotten_store = gotten_store;
1886    
1887      /* 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
1888      help with the matching. */      help with the matching, unless the pattern has the SS option, which
1889        suppresses the effect of /S (used for a few test patterns where studying is
1890        never sensible). */
1891    
1892      if (do_study)      if (do_study || (force_study >= 0 && !no_force_study))
1893        {        {
1894        if (timeit > 0)        if (timeit > 0)
1895          {          {
# Line 1754  while (!done) Line 1897  while (!done)
1897          clock_t time_taken;          clock_t time_taken;
1898          clock_t start_time = clock();          clock_t start_time = clock();
1899          for (i = 0; i < timeit; i++)          for (i = 0; i < timeit; i++)
1900            extra = pcre_study(re, study_options, &error);            extra = pcre_study(re, study_options | force_study_options, &error);
1901          time_taken = clock() - start_time;          time_taken = clock() - start_time;
1902          if (extra != NULL) free(extra);          if (extra != NULL) pcre_free_study(extra);
1903          fprintf(outfile, "  Study time %.4f milliseconds\n",          fprintf(outfile, "  Study time %.4f milliseconds\n",
1904            (((double)time_taken * 1000.0) / (double)timeit) /            (((double)time_taken * 1000.0) / (double)timeit) /
1905              (double)CLOCKS_PER_SEC);              (double)CLOCKS_PER_SEC);
1906          }          }
1907        extra = pcre_study(re, study_options, &error);        extra = pcre_study(re, study_options | force_study_options, &error);
1908        if (error != NULL)        if (error != NULL)
1909          fprintf(outfile, "Failed to study: %s\n", error);          fprintf(outfile, "Failed to study: %s\n", error);
1910        else if (extra != NULL)        else if (extra != NULL)
# Line 1900  while (!done) Line 2043  while (!done)
2043        if (do_flip) all_options = byteflip(all_options, sizeof(all_options));        if (do_flip) all_options = byteflip(all_options, sizeof(all_options));
2044    
2045        if (get_options == 0) fprintf(outfile, "No options\n");        if (get_options == 0) fprintf(outfile, "No options\n");
2046          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",
2047            ((get_options & PCRE_ANCHORED) != 0)? " anchored" : "",            ((get_options & PCRE_ANCHORED) != 0)? " anchored" : "",
2048            ((get_options & PCRE_CASELESS) != 0)? " caseless" : "",            ((get_options & PCRE_CASELESS) != 0)? " caseless" : "",
2049            ((get_options & PCRE_EXTENDED) != 0)? " extended" : "",            ((get_options & PCRE_EXTENDED) != 0)? " extended" : "",
# Line 1916  while (!done) Line 2059  while (!done)
2059            ((get_options & PCRE_UTF8) != 0)? " utf8" : "",            ((get_options & PCRE_UTF8) != 0)? " utf8" : "",
2060            ((get_options & PCRE_UCP) != 0)? " ucp" : "",            ((get_options & PCRE_UCP) != 0)? " ucp" : "",
2061            ((get_options & PCRE_NO_UTF8_CHECK) != 0)? " no_utf8_check" : "",            ((get_options & PCRE_NO_UTF8_CHECK) != 0)? " no_utf8_check" : "",
2062              ((get_options & PCRE_NO_START_OPTIMIZE) != 0)? " no_start_optimize" : "",
2063            ((get_options & PCRE_DUPNAMES) != 0)? " dupnames" : "");            ((get_options & PCRE_DUPNAMES) != 0)? " dupnames" : "");
2064    
2065        if (jchanged) fprintf(outfile, "Duplicate name status changes\n");        if (jchanged) fprintf(outfile, "Duplicate name status changes\n");
# Line 1983  while (!done) Line 2127  while (!done)
2127        /* 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
2128        value, but it varies, depending on the computer architecture, and        value, but it varies, depending on the computer architecture, and
2129        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
2130        flipped.) */        flipped.) If study was forced by an external -s, don't show this
2131          information unless -i or -d was also present. This means that, except
2132          when auto-callouts are involved, the output from runs with and without
2133          -s should be identical. */
2134    
2135        if (do_study)        if (do_study || (force_study >= 0 && showinfo && !no_force_study))
2136          {          {
2137          if (extra == NULL)          if (extra == NULL)
2138            fprintf(outfile, "Study returned NULL\n");            fprintf(outfile, "Study returned NULL\n");
# Line 2029  while (!done) Line 2176  while (!done)
2176              fprintf(outfile, "\n");              fprintf(outfile, "\n");
2177              }              }
2178            }            }
2179    
2180            /* Show this only if the JIT was set by /S, not by -s. */
2181    
2182            if ((study_options & PCRE_STUDY_JIT_COMPILE) != 0)
2183              {
2184              int jit;
2185              new_info(re, extra, PCRE_INFO_JIT, &jit);
2186              if (jit)
2187                fprintf(outfile, "JIT study was successful\n");
2188              else
2189    #ifdef SUPPORT_JIT
2190                fprintf(outfile, "JIT study was not successful\n");
2191    #else
2192                fprintf(outfile, "JIT support is not available in this version of PCRE\n");
2193    #endif
2194              }
2195          }          }
2196        }        }
2197    
# Line 2063  while (!done) Line 2226  while (!done)
2226            }            }
2227          else          else
2228            {            {
2229            fprintf(outfile, "Compiled regex written to %s\n", to_file);            fprintf(outfile, "Compiled pattern written to %s\n", to_file);
2230    
2231              /* If there is study data, write it. */
2232    
2233            if (extra != NULL)            if (extra != NULL)
2234              {              {
2235              if (fwrite(extra->study_data, 1, true_study_size, f) <              if (fwrite(extra->study_data, 1, true_study_size, f) <
# Line 2073  while (!done) Line 2239  while (!done)
2239                  strerror(errno));                  strerror(errno));
2240                }                }
2241              else fprintf(outfile, "Study data written to %s\n", to_file);              else fprintf(outfile, "Study data written to %s\n", to_file);
   
2242              }              }
2243            }            }
2244          fclose(f);          fclose(f);
2245          }          }
2246    
2247        new_free(re);        new_free(re);
2248        if (extra != NULL) new_free(extra);        if (extra != NULL) pcre_free_study(extra);
2249        if (locale_set)        if (locale_set)
2250          {          {
2251          new_free((void *)tables);          new_free((void *)tables);
2252          setlocale(LC_CTYPE, "C");          setlocale(LC_CTYPE, "C");
2253          locale_set = 0;          locale_set = 0;
2254          }          }
2255        continue;  /* With next regex */        continue;  /* With next regex */
2256        }        }
2257      }        /* End of non-POSIX compile */      }        /* End of non-POSIX compile */
# Line 2108  while (!done) Line 2273  while (!done)
2273      int getlist = 0;      int getlist = 0;
2274      int gmatched = 0;      int gmatched = 0;
2275      int start_offset = 0;      int start_offset = 0;
2276        int start_offset_sign = 1;
2277      int g_notempty = 0;      int g_notempty = 0;
2278      int use_dfa = 0;      int use_dfa = 0;
2279    
# Line 2121  while (!done) Line 2287  while (!done)
2287    
2288      pcre_callout = callout;      pcre_callout = callout;
2289      first_callout = 1;      first_callout = 1;
2290        last_callout_mark = NULL;
2291      callout_extra = 0;      callout_extra = 0;
2292      callout_count = 0;      callout_count = 0;
2293      callout_fail_count = 999999;      callout_fail_count = 999999;
# Line 2137  while (!done) Line 2304  while (!done)
2304          {          {
2305          if (len > 0)    /* Reached EOF without hitting a newline */          if (len > 0)    /* Reached EOF without hitting a newline */
2306            {            {
2307            fprintf(outfile, "\n");            fprintf(outfile, "\n");
2308            break;            break;
2309            }            }
2310          done = 1;          done = 1;
2311          goto CONTINUE;          goto CONTINUE;
2312          }          }
# Line 2240  while (!done) Line 2407  while (!done)
2407          continue;          continue;
2408    
2409          case '>':          case '>':
2410            if (*p == '-')
2411              {
2412              start_offset_sign = -1;
2413              p++;
2414              }
2415          while(isdigit(*p)) start_offset = start_offset * 10 + *p++ - '0';          while(isdigit(*p)) start_offset = start_offset * 10 + *p++ - '0';
2416            start_offset *= start_offset_sign;
2417          continue;          continue;
2418    
2419          case 'A':  /* Option setting */          case 'A':  /* Option setting */
# Line 2313  while (!done) Line 2486  while (!done)
2486  #endif  #endif
2487            use_dfa = 1;            use_dfa = 1;
2488          continue;          continue;
2489    #endif
2490    
2491    #if !defined NODFA
2492          case 'F':          case 'F':
2493          options |= PCRE_DFA_SHORTEST;          options |= PCRE_DFA_SHORTEST;
2494          continue;          continue;
# Line 2337  while (!done) Line 2512  while (!done)
2512            getnamesptr = npp;            getnamesptr = npp;
2513            }            }
2514          continue;          continue;
2515    
2516            case 'J':
2517            while(isdigit(*p)) n = n * 10 + *p++ - '0';
2518            if (extra != NULL
2519                && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0
2520                && extra->executable_jit != NULL)
2521              {
2522              if (jit_stack != NULL) pcre_jit_stack_free(jit_stack);
2523              jit_stack = pcre_jit_stack_alloc(1, n * 1024);
2524              pcre_assign_jit_stack(extra, jit_callback, jit_stack);
2525              }
2526            continue;
2527    
2528          case 'L':          case 'L':
2529          getlist = 1;          getlist = 1;
# Line 2434  while (!done) Line 2621  while (!done)
2621        }        }
2622      *q = 0;      *q = 0;
2623      len = (int)(q - dbuffer);      len = (int)(q - dbuffer);
2624    
2625      /* Move the data to the end of the buffer so that a read over the end of      /* Move the data to the end of the buffer so that a read over the end of
2626      the buffer will be seen by valgrind, even if it doesn't cause a crash. If      the buffer will be seen by valgrind, even if it doesn't cause a crash. If
2627      we are using the POSIX interface, we must include the terminating zero. */      we are using the POSIX interface, we must include the terminating zero. */
# Line 2496  while (!done) Line 2683  while (!done)
2683              (void)pchars(dbuffer + pmatch[i].rm_so,              (void)pchars(dbuffer + pmatch[i].rm_so,
2684                pmatch[i].rm_eo - pmatch[i].rm_so, outfile);                pmatch[i].rm_eo - pmatch[i].rm_so, outfile);
2685              fprintf(outfile, "\n");              fprintf(outfile, "\n");
2686              if (i == 0 && do_showrest)              if (do_showcaprest || (i == 0 && do_showrest))
2687                {                {
2688                fprintf(outfile, " 0+ ");                fprintf(outfile, "%2d+ ", (int)i);
2689                (void)pchars(dbuffer + pmatch[i].rm_eo, len - pmatch[i].rm_eo,                (void)pchars(dbuffer + pmatch[i].rm_eo, len - pmatch[i].rm_eo,
2690                  outfile);                  outfile);
2691                fprintf(outfile, "\n");                fprintf(outfile, "\n");
# Line 2548  while (!done) Line 2735  while (!done)
2735    
2736        /* 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
2737        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
2738        for the recursion limit. */        for the recursion limit. The match limits are relevant only to the normal
2739          running of pcre_exec(), so disable the JIT optimization. This makes it
2740          possible to run the same set of tests with and without JIT externally
2741          requested. */
2742    
2743        if (find_match_limit)        if (find_match_limit)
2744          {          {
# Line 2557  while (!done) Line 2747  while (!done)
2747            extra = (pcre_extra *)malloc(sizeof(pcre_extra));            extra = (pcre_extra *)malloc(sizeof(pcre_extra));
2748            extra->flags = 0;            extra->flags = 0;
2749            }            }
2750            else extra->flags &= ~PCRE_EXTRA_EXECUTABLE_JIT;
2751    
2752          (void)check_match_limit(re, extra, bptr, len, start_offset,          (void)check_match_limit(re, extra, bptr, len, start_offset,
2753            options|g_notempty, use_offsets, use_size_offsets,            options|g_notempty, use_offsets, use_size_offsets,
2754            PCRE_EXTRA_MATCH_LIMIT, &(extra->match_limit),            PCRE_EXTRA_MATCH_LIMIT, &(extra->match_limit),
# Line 2640  while (!done) Line 2831  while (!done)
2831              }              }
2832            }            }
2833    
2834            /* do_allcaps requests showing of all captures in the pattern, to check
2835            unset ones at the end. */
2836    
2837            if (do_allcaps)
2838              {
2839              new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count);
2840              count++;   /* Allow for full match */
2841              if (count * 2 > use_size_offsets) count = use_size_offsets/2;
2842              }
2843    
2844            /* Output the captured substrings */
2845    
2846          for (i = 0; i < count * 2; i += 2)          for (i = 0; i < count * 2; i += 2)
2847            {            {
2848            if (use_offsets[i] < 0)            if (use_offsets[i] < 0)
2849                {
2850                if (use_offsets[i] != -1)
2851                  fprintf(outfile, "ERROR: bad negative value %d for offset %d\n",
2852                    use_offsets[i], i);
2853                if (use_offsets[i+1] != -1)
2854                  fprintf(outfile, "ERROR: bad negative value %d for offset %d\n",
2855                    use_offsets[i+1], i+1);
2856              fprintf(outfile, "%2d: <unset>\n", i/2);              fprintf(outfile, "%2d: <unset>\n", i/2);
2857                }
2858            else            else
2859              {              {
2860              fprintf(outfile, "%2d: ", i/2);              fprintf(outfile, "%2d: ", i/2);
2861              (void)pchars(bptr + use_offsets[i],              (void)pchars(bptr + use_offsets[i],
2862                use_offsets[i+1] - use_offsets[i], outfile);                use_offsets[i+1] - use_offsets[i], outfile);
2863              fprintf(outfile, "\n");              fprintf(outfile, "\n");
2864              if (i == 0)              if (do_showcaprest || (i == 0 && do_showrest))
2865                {                {
2866                if (do_showrest)                fprintf(outfile, "%2d+ ", i/2);
2867                  {                (void)pchars(bptr + use_offsets[i+1], len - use_offsets[i+1],
2868                  fprintf(outfile, " 0+ ");                  outfile);
2869                  (void)pchars(bptr + use_offsets[i+1], len - use_offsets[i+1],                fprintf(outfile, "\n");
                   outfile);  
                 fprintf(outfile, "\n");  
                 }  
2870                }                }
2871              }              }
2872            }            }
# Line 2738  while (!done) Line 2946  while (!done)
2946                fprintf(outfile, "%2dL %s\n", i, stringlist[i]);                fprintf(outfile, "%2dL %s\n", i, stringlist[i]);
2947              if (stringlist[i] != NULL)              if (stringlist[i] != NULL)
2948                fprintf(outfile, "string list not terminated by NULL\n");                fprintf(outfile, "string list not terminated by NULL\n");
             /* free((void *)stringlist); */  
2949              pcre_free_substring_list(stringlist);              pcre_free_substring_list(stringlist);
2950              }              }
2951            }            }
# Line 2765  while (!done) Line 2972  while (!done)
2972        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
2973        string - that was checked before setting g_notempty.        string - that was checked before setting g_notempty.
2974    
2975        Complication arises in the case when the newline option is "any" or        Complication arises in the case when the newline convention is "any",
2976        "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
2977        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,
2978        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
2979        Fudge the offset value to achieve this.        pcre_exec(). Fudge the offset value to achieve this. We check for a
2980          newline setting in the pattern; if none was set, use pcre_config() to
2981          find the default.
2982    
2983        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
2984        character, not one byte. */        character, not one byte. */
# Line 2794  while (!done) Line 3003  while (!done)
3003                      (d == -1)? PCRE_NEWLINE_ANY : 0;                      (d == -1)? PCRE_NEWLINE_ANY : 0;
3004              }              }
3005            if (((obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANY ||            if (((obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANY ||
3006                   (obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_CRLF ||
3007                 (obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANYCRLF)                 (obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANYCRLF)
3008                &&                &&
3009                start_offset < len - 1 &&                start_offset < len - 1 &&
# Line 2804  while (!done) Line 3014  while (!done)
3014              {              {
3015              while (start_offset + onechar < len)              while (start_offset + onechar < len)
3016                {                {
3017                int tb = bptr[start_offset+onechar];                if ((bptr[start_offset+onechar] & 0xc0) != 0x80) break;
3018                if (tb <= 127) break;                onechar++;
               tb &= 0xc0;  
               if (tb != 0 && tb != 0xc0) onechar++;  
3019                }                }
3020              }              }
3021            use_offsets[1] = start_offset + onechar;            use_offsets[1] = start_offset + onechar;
3022            }            }
3023          else          else
3024            {            {
3025            if (count == PCRE_ERROR_NOMATCH)            switch(count)
3026              {              {
3027                case PCRE_ERROR_NOMATCH:
3028              if (gmatched == 0)              if (gmatched == 0)
3029                {                {
3030                if (markptr == NULL) fprintf(outfile, "No match\n");                if (markptr == NULL) fprintf(outfile, "No match\n");
3031                  else fprintf(outfile, "No match, mark = %s\n", markptr);                  else fprintf(outfile, "No match, mark = %s\n", markptr);
3032                }                }
3033                break;
3034    
3035                case PCRE_ERROR_BADUTF8:
3036                case PCRE_ERROR_SHORTUTF8:
3037                fprintf(outfile, "Error %d (%s UTF-8 string)", count,
3038                  (count == PCRE_ERROR_BADUTF8)? "bad" : "short");
3039                if (use_size_offsets >= 2)
3040                  fprintf(outfile, " offset=%d reason=%d", use_offsets[0],
3041                    use_offsets[1]);
3042                fprintf(outfile, "\n");
3043                break;
3044    
3045                default:
3046                if (count < 0 && (-count) < sizeof(errtexts)/sizeof(const char *))
3047                  fprintf(outfile, "Error %d (%s)\n", count, errtexts[-count]);
3048                else
3049                  fprintf(outfile, "Error %d (Unexpected value)\n", count);
3050                break;
3051              }              }
3052            else fprintf(outfile, "Error %d\n", count);  
3053            break;  /* Out of the /g loop */            break;  /* Out of the /g loop */
3054            }            }
3055          }          }
# Line 2869  while (!done) Line 3096  while (!done)
3096  #endif  #endif
3097    
3098    if (re != NULL) new_free(re);    if (re != NULL) new_free(re);
3099    if (extra != NULL) new_free(extra);    if (extra != NULL) pcre_free_study(extra);
3100    if (locale_set)    if (locale_set)
3101      {      {
3102      new_free((void *)tables);      new_free((void *)tables);
3103      setlocale(LC_CTYPE, "C");      setlocale(LC_CTYPE, "C");
3104      locale_set = 0;      locale_set = 0;
3105      }      }
3106      if (jit_stack != NULL)
3107        {
3108        pcre_jit_stack_free(jit_stack);
3109        jit_stack = NULL;
3110        }
3111    }    }
3112    
3113  if (infile == stdin) fprintf(outfile, "\n");  if (infile == stdin) fprintf(outfile, "\n");

Legend:
Removed from v.541  
changed lines
  Added in v.675

webmaster@exim.org
ViewVC Help
Powered by ViewVC 1.1.12