/[pcre]/code/branches/pcre16/pcretest.c
ViewVC logotype

Diff of /code/branches/pcre16/pcretest.c

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

revision 545 by ph10, Wed Jun 16 10:51:15 2010 UTC revision 735 by ph10, Thu Oct 13 15:51:27 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 516  static const unsigned char tables1[] = { Line 560  static const unsigned char tables1[] = {
560    
561    
562    
563    
564    #ifndef HAVE_STRERROR
565    /*************************************************
566    *     Provide strerror() for non-ANSI libraries  *
567    *************************************************/
568    
569    /* Some old-fashioned systems still around (e.g. SunOS4) don't have strerror()
570    in their libraries, but can provide the same facility by this simple
571    alternative function. */
572    
573    extern int   sys_nerr;
574    extern char *sys_errlist[];
575    
576    char *
577    strerror(int n)
578    {
579    if (n < 0 || n >= sys_nerr) return "unknown error number";
580    return sys_errlist[n];
581    }
582    #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  /*************************************************  /*************************************************
596  *        Read or extend an input line            *  *        Read or extend an input line            *
597  *************************************************/  *************************************************/
# Line 896  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 915  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 934  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 1123  printf("  -p       use POSIX interface\n Line 1205  printf("  -p       use POSIX interface\n
1205  #endif  #endif
1206  printf("  -q       quiet: do not output PCRE version number at start\n");  printf("  -q       quiet: do not output PCRE version number at start\n");
1207  printf("  -S <n>   set stack size to <n> megabytes\n");  printf("  -S <n>   set stack size to <n> megabytes\n");
1208  printf("  -s       output store (memory) used information\n"  printf("  -s       force each pattern to be studied at basic level\n"
1209           "  -s+      force each pattern to be studied, using JIT if available\n"
1210         "  -t       time compilation and execution\n");         "  -t       time compilation and execution\n");
1211  printf("  -t <n>   time compilation and execution, repeating <n> times\n");  printf("  -t <n>   time compilation and execution, repeating <n> times\n");
1212  printf("  -tm      time execution (matching) only\n");  printf("  -tm      time execution (matching) only\n");
# Line 1151  int timeit = 0; Line 1234  int timeit = 0;
1234  int timeitm = 0;  int timeitm = 0;
1235  int showinfo = 0;  int showinfo = 0;
1236  int showstore = 0;  int showstore = 0;
1237    int force_study = -1;
1238    int force_study_options = 0;
1239  int quiet = 0;  int quiet = 0;
1240  int size_offsets = 45;  int size_offsets = 45;
1241  int size_offsets_max;  int size_offsets_max;
# Line 1164  int all_use_dfa = 0; Line 1249  int all_use_dfa = 0;
1249  int yield = 0;  int yield = 0;
1250  int stack_size;  int stack_size;
1251    
1252    pcre_jit_stack *jit_stack = NULL;
1253    
1254    
1255  /* 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
1256  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. */
1257    
# Line 1199  while (argc > 1 && argv[op][0] == '-') Line 1287  while (argc > 1 && argv[op][0] == '-')
1287    {    {
1288    unsigned char *endptr;    unsigned char *endptr;
1289    
1290    if (strcmp(argv[op], "-s") == 0 || strcmp(argv[op], "-m") == 0)    if (strcmp(argv[op], "-m") == 0) showstore = 1;
1291      showstore = 1;    else if (strcmp(argv[op], "-s") == 0) force_study = 0;
1292      else if (strcmp(argv[op], "-s+") == 0)
1293        {
1294        force_study = 1;
1295        force_study_options = PCRE_STUDY_JIT_COMPILE;
1296        }
1297    else if (strcmp(argv[op], "-q") == 0) quiet = 1;    else if (strcmp(argv[op], "-q") == 0) quiet = 1;
1298    else if (strcmp(argv[op], "-b") == 0) debug = 1;    else if (strcmp(argv[op], "-b") == 0) debug = 1;
1299    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 1327  while (argc > 1 && argv[op][0] == '-')
1327        ((stack_size = get_value((unsigned char *)argv[op+1], &endptr)),        ((stack_size = get_value((unsigned char *)argv[op+1], &endptr)),
1328          *endptr == 0))          *endptr == 0))
1329      {      {
1330  #if defined(_WIN32) || defined(WIN32)  #if defined(_WIN32) || defined(WIN32) || defined(__minix)
1331      printf("PCRE: -S not supported on this OS\n");      printf("PCRE: -S not supported on this OS\n");
1332      exit(1);      exit(1);
1333  #else  #else
# Line 1265  while (argc > 1 && argv[op][0] == '-') Line 1358  while (argc > 1 && argv[op][0] == '-')
1358      printf("  %sUTF-8 support\n", rc? "" : "No ");      printf("  %sUTF-8 support\n", rc? "" : "No ");
1359      (void)pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &rc);      (void)pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &rc);
1360      printf("  %sUnicode properties support\n", rc? "" : "No ");      printf("  %sUnicode properties support\n", rc? "" : "No ");
1361        (void)pcre_config(PCRE_CONFIG_JIT, &rc);
1362        if (rc)
1363          printf("  Just-in-time compiler support\n");
1364        else
1365          printf("  No just-in-time compiler support\n");
1366      (void)pcre_config(PCRE_CONFIG_NEWLINE, &rc);      (void)pcre_config(PCRE_CONFIG_NEWLINE, &rc);
1367      /* Note that these values are always the ASCII values, even      /* Note that these values are always the ASCII values, even
1368      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 1468  while (!done)
1468    const unsigned char *tables = NULL;    const unsigned char *tables = NULL;
1469    unsigned long int true_size, true_study_size = 0;    unsigned long int true_size, true_study_size = 0;
1470    size_t size, regex_gotten_store;    size_t size, regex_gotten_store;
1471      int do_allcaps = 0;
1472    int do_mark = 0;    int do_mark = 0;
1473    int do_study = 0;    int do_study = 0;
1474      int no_force_study = 0;
1475    int do_debug = debug;    int do_debug = debug;
1476    int do_G = 0;    int do_G = 0;
1477    int do_g = 0;    int do_g = 0;
1478    int do_showinfo = showinfo;    int do_showinfo = showinfo;
1479    int do_showrest = 0;    int do_showrest = 0;
1480      int do_showcaprest = 0;
1481    int do_flip = 0;    int do_flip = 0;
1482    int erroroffset, len, delimiter, poffset;    int erroroffset, len, delimiter, poffset;
1483    
# Line 1438  while (!done) Line 1539  while (!done)
1539          }          }
1540        }        }
1541    
1542      fprintf(outfile, "Compiled regex%s loaded from %s\n",      fprintf(outfile, "Compiled pattern%s loaded from %s\n",
1543        do_flip? " (byte-inverted)" : "", p);        do_flip? " (byte-inverted)" : "", p);
1544    
1545      /* 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 1547  while (!done)
1547      new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);      new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);
1548      use_utf8 = (get_options & PCRE_UTF8) != 0;      use_utf8 = (get_options & PCRE_UTF8) != 0;
1549    
1550      /* Now see if there is any following study data */      /* Now see if there is any following study data. */
1551    
1552      if (true_study_size != 0)      if (true_study_size != 0)
1553        {        {
# Line 1462  while (!done) Line 1563  while (!done)
1563          {          {
1564          FAIL_READ:          FAIL_READ:
1565          fprintf(outfile, "Failed to read data from %s\n", p);          fprintf(outfile, "Failed to read data from %s\n", p);
1566          if (extra != NULL) new_free(extra);          if (extra != NULL) pcre_free_study(extra);
1567          if (re != NULL) new_free(re);          if (re != NULL) new_free(re);
1568          fclose(f);          fclose(f);
1569          continue;          continue;
# Line 1528  while (!done) Line 1629  while (!done)
1629    /* Look for options after final delimiter */    /* Look for options after final delimiter */
1630    
1631    options = 0;    options = 0;
   study_options = 0;  
1632    log_store = showstore;  /* default from command line */    log_store = showstore;  /* default from command line */
1633    
1634    while (*pp != 0)    while (*pp != 0)
# Line 1542  while (!done) Line 1642  while (!done)
1642        case 's': options |= PCRE_DOTALL; break;        case 's': options |= PCRE_DOTALL; break;
1643        case 'x': options |= PCRE_EXTENDED; break;        case 'x': options |= PCRE_EXTENDED; break;
1644    
1645        case '+': do_showrest = 1; break;        case '+':
1646          if (do_showrest) do_showcaprest = 1; else do_showrest = 1;
1647          break;
1648    
1649          case '=': do_allcaps = 1; break;
1650        case 'A': options |= PCRE_ANCHORED; break;        case 'A': options |= PCRE_ANCHORED; break;
1651        case 'B': do_debug = 1; break;        case 'B': do_debug = 1; break;
1652        case 'C': options |= PCRE_AUTO_CALLOUT; break;        case 'C': options |= PCRE_AUTO_CALLOUT; break;
# Line 1560  while (!done) Line 1664  while (!done)
1664        case 'P': do_posix = 1; break;        case 'P': do_posix = 1; break;
1665  #endif  #endif
1666    
1667        case 'S': do_study = 1; break;        case 'S':
1668          if (do_study == 0)
1669            {
1670            do_study = 1;
1671            if (*pp == '+')
1672              {
1673              study_options |= PCRE_STUDY_JIT_COMPILE;
1674              pp++;
1675              }
1676            }
1677          else
1678            {
1679            do_study = 0;
1680            no_force_study = 1;
1681            }
1682          break;
1683    
1684        case 'U': options |= PCRE_UNGREEDY; break;        case 'U': options |= PCRE_UNGREEDY; break;
1685        case 'W': options |= PCRE_UCP; break;        case 'W': options |= PCRE_UCP; break;
1686        case 'X': options |= PCRE_EXTRA; break;        case 'X': options |= PCRE_EXTRA; break;
1687          case 'Y': options |= PCRE_NO_START_OPTIMISE; break;
1688        case 'Z': debug_lengths = 0; break;        case 'Z': debug_lengths = 0; break;
1689        case '8': options |= PCRE_UTF8; use_utf8 = 1; break;        case '8': options |= PCRE_UTF8; use_utf8 = 1; break;
1690        case '?': options |= PCRE_NO_UTF8_CHECK; break;        case '?': options |= PCRE_NO_UTF8_CHECK; break;
# Line 1743  while (!done) Line 1864  while (!done)
1864      true_size = ((real_pcre *)re)->size;      true_size = ((real_pcre *)re)->size;
1865      regex_gotten_store = gotten_store;      regex_gotten_store = gotten_store;
1866    
1867      /* 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
1868      help with the matching. */      help with the matching, unless the pattern has the SS option, which
1869        suppresses the effect of /S (used for a few test patterns where studying is
1870        never sensible). */
1871    
1872      if (do_study)      if (do_study || (force_study >= 0 && !no_force_study))
1873        {        {
1874        if (timeit > 0)        if (timeit > 0)
1875          {          {
# Line 1754  while (!done) Line 1877  while (!done)
1877          clock_t time_taken;          clock_t time_taken;
1878          clock_t start_time = clock();          clock_t start_time = clock();
1879          for (i = 0; i < timeit; i++)          for (i = 0; i < timeit; i++)
1880            extra = pcre_study(re, study_options, &error);            extra = pcre_study(re, study_options | force_study_options, &error);
1881          time_taken = clock() - start_time;          time_taken = clock() - start_time;
1882          if (extra != NULL) free(extra);          if (extra != NULL) pcre_free_study(extra);
1883          fprintf(outfile, "  Study time %.4f milliseconds\n",          fprintf(outfile, "  Study time %.4f milliseconds\n",
1884            (((double)time_taken * 1000.0) / (double)timeit) /            (((double)time_taken * 1000.0) / (double)timeit) /
1885              (double)CLOCKS_PER_SEC);              (double)CLOCKS_PER_SEC);
1886          }          }
1887        extra = pcre_study(re, study_options, &error);        extra = pcre_study(re, study_options | force_study_options, &error);
1888        if (error != NULL)        if (error != NULL)
1889          fprintf(outfile, "Failed to study: %s\n", error);          fprintf(outfile, "Failed to study: %s\n", error);
1890        else if (extra != NULL)        else if (extra != NULL)
# Line 1900  while (!done) Line 2023  while (!done)
2023        if (do_flip) all_options = byteflip(all_options, sizeof(all_options));        if (do_flip) all_options = byteflip(all_options, sizeof(all_options));
2024    
2025        if (get_options == 0) fprintf(outfile, "No options\n");        if (get_options == 0) fprintf(outfile, "No options\n");
2026          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",
2027            ((get_options & PCRE_ANCHORED) != 0)? " anchored" : "",            ((get_options & PCRE_ANCHORED) != 0)? " anchored" : "",
2028            ((get_options & PCRE_CASELESS) != 0)? " caseless" : "",            ((get_options & PCRE_CASELESS) != 0)? " caseless" : "",
2029            ((get_options & PCRE_EXTENDED) != 0)? " extended" : "",            ((get_options & PCRE_EXTENDED) != 0)? " extended" : "",
# Line 1916  while (!done) Line 2039  while (!done)
2039            ((get_options & PCRE_UTF8) != 0)? " utf8" : "",            ((get_options & PCRE_UTF8) != 0)? " utf8" : "",
2040            ((get_options & PCRE_UCP) != 0)? " ucp" : "",            ((get_options & PCRE_UCP) != 0)? " ucp" : "",
2041            ((get_options & PCRE_NO_UTF8_CHECK) != 0)? " no_utf8_check" : "",            ((get_options & PCRE_NO_UTF8_CHECK) != 0)? " no_utf8_check" : "",
2042              ((get_options & PCRE_NO_START_OPTIMIZE) != 0)? " no_start_optimize" : "",
2043            ((get_options & PCRE_DUPNAMES) != 0)? " dupnames" : "");            ((get_options & PCRE_DUPNAMES) != 0)? " dupnames" : "");
2044    
2045        if (jchanged) fprintf(outfile, "Duplicate name status changes\n");        if (jchanged) fprintf(outfile, "Duplicate name status changes\n");
# Line 1983  while (!done) Line 2107  while (!done)
2107        /* 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
2108        value, but it varies, depending on the computer architecture, and        value, but it varies, depending on the computer architecture, and
2109        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
2110        flipped.) */        flipped.) If study was forced by an external -s, don't show this
2111          information unless -i or -d was also present. This means that, except
2112          when auto-callouts are involved, the output from runs with and without
2113          -s should be identical. */
2114    
2115        if (do_study)        if (do_study || (force_study >= 0 && showinfo && !no_force_study))
2116          {          {
2117          if (extra == NULL)          if (extra == NULL)
2118            fprintf(outfile, "Study returned NULL\n");            fprintf(outfile, "Study returned NULL\n");
# Line 2029  while (!done) Line 2156  while (!done)
2156              fprintf(outfile, "\n");              fprintf(outfile, "\n");
2157              }              }
2158            }            }
2159    
2160            /* Show this only if the JIT was set by /S, not by -s. */
2161    
2162            if ((study_options & PCRE_STUDY_JIT_COMPILE) != 0)
2163              {
2164              int jit;
2165              new_info(re, extra, PCRE_INFO_JIT, &jit);
2166              if (jit)
2167                fprintf(outfile, "JIT study was successful\n");
2168              else
2169    #ifdef SUPPORT_JIT
2170                fprintf(outfile, "JIT study was not successful\n");
2171    #else
2172                fprintf(outfile, "JIT support is not available in this version of PCRE\n");
2173    #endif
2174              }
2175          }          }
2176        }        }
2177    
# Line 2063  while (!done) Line 2206  while (!done)
2206            }            }
2207          else          else
2208            {            {
2209            fprintf(outfile, "Compiled regex written to %s\n", to_file);            fprintf(outfile, "Compiled pattern written to %s\n", to_file);
2210    
2211              /* If there is study data, write it. */
2212    
2213            if (extra != NULL)            if (extra != NULL)
2214              {              {
2215              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 2219  while (!done)
2219                  strerror(errno));                  strerror(errno));
2220                }                }
2221              else fprintf(outfile, "Study data written to %s\n", to_file);              else fprintf(outfile, "Study data written to %s\n", to_file);
   
2222              }              }
2223            }            }
2224          fclose(f);          fclose(f);
2225          }          }
2226    
2227        new_free(re);        new_free(re);
2228        if (extra != NULL) new_free(extra);        if (extra != NULL) pcre_free_study(extra);
2229        if (locale_set)        if (locale_set)
2230          {          {
2231          new_free((void *)tables);          new_free((void *)tables);
# Line 2108  while (!done) Line 2253  while (!done)
2253      int getlist = 0;      int getlist = 0;
2254      int gmatched = 0;      int gmatched = 0;
2255      int start_offset = 0;      int start_offset = 0;
2256        int start_offset_sign = 1;
2257      int g_notempty = 0;      int g_notempty = 0;
2258      int use_dfa = 0;      int use_dfa = 0;
2259    
# Line 2121  while (!done) Line 2267  while (!done)
2267    
2268      pcre_callout = callout;      pcre_callout = callout;
2269      first_callout = 1;      first_callout = 1;
2270        last_callout_mark = NULL;
2271      callout_extra = 0;      callout_extra = 0;
2272      callout_count = 0;      callout_count = 0;
2273      callout_fail_count = 999999;      callout_fail_count = 999999;
# Line 2199  while (!done) Line 2346  while (!done)
2346            {            {
2347            unsigned char *pt = p;            unsigned char *pt = p;
2348            c = 0;            c = 0;
2349            while (isxdigit(*(++pt)))  
2350              c = c * 16 + tolower(*pt) - ((isdigit(*pt))? '0' : 'W');            /* We used to have "while (isxdigit(*(++pt)))" here, but it fails
2351              when isxdigit() is a macro that refers to its argument more than
2352              once. This is banned by the C Standard, but apparently happens in at
2353              least one MacOS environment. */
2354    
2355              for (pt++; isxdigit(*pt); pt++)
2356                c = c * 16 + tolower(*pt) - ((isdigit(*pt))? '0' : 'a' - 10);
2357            if (*pt == '}')            if (*pt == '}')
2358              {              {
2359              unsigned char buff8[8];              unsigned char buff8[8];
# Line 2230  while (!done) Line 2383  while (!done)
2383          c = 0;          c = 0;
2384          while (i++ < 2 && isxdigit(*p))          while (i++ < 2 && isxdigit(*p))
2385            {            {
2386            c = c * 16 + tolower(*p) - ((isdigit(*p))? '0' : 'W');            c = c * 16 + tolower(*p) - ((isdigit(*p))? '0' : 'a' - 10);
2387            p++;            p++;
2388            }            }
2389          break;          break;
# Line 2240  while (!done) Line 2393  while (!done)
2393          continue;          continue;
2394    
2395          case '>':          case '>':
2396            if (*p == '-')
2397              {
2398              start_offset_sign = -1;
2399              p++;
2400              }
2401          while(isdigit(*p)) start_offset = start_offset * 10 + *p++ - '0';          while(isdigit(*p)) start_offset = start_offset * 10 + *p++ - '0';
2402            start_offset *= start_offset_sign;
2403          continue;          continue;
2404    
2405          case 'A':  /* Option setting */          case 'A':  /* Option setting */
# Line 2313  while (!done) Line 2472  while (!done)
2472  #endif  #endif
2473            use_dfa = 1;            use_dfa = 1;
2474          continue;          continue;
2475    #endif
2476    
2477    #if !defined NODFA
2478          case 'F':          case 'F':
2479          options |= PCRE_DFA_SHORTEST;          options |= PCRE_DFA_SHORTEST;
2480          continue;          continue;
# Line 2338  while (!done) Line 2499  while (!done)
2499            }            }
2500          continue;          continue;
2501    
2502            case 'J':
2503            while(isdigit(*p)) n = n * 10 + *p++ - '0';
2504            if (extra != NULL
2505                && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0
2506                && extra->executable_jit != NULL)
2507              {
2508              if (jit_stack != NULL) pcre_jit_stack_free(jit_stack);
2509              jit_stack = pcre_jit_stack_alloc(1, n * 1024);
2510              pcre_assign_jit_stack(extra, jit_callback, jit_stack);
2511              }
2512            continue;
2513    
2514          case 'L':          case 'L':
2515          getlist = 1;          getlist = 1;
2516          continue;          continue;
# Line 2496  while (!done) Line 2669  while (!done)
2669              (void)pchars(dbuffer + pmatch[i].rm_so,              (void)pchars(dbuffer + pmatch[i].rm_so,
2670                pmatch[i].rm_eo - pmatch[i].rm_so, outfile);                pmatch[i].rm_eo - pmatch[i].rm_so, outfile);
2671              fprintf(outfile, "\n");              fprintf(outfile, "\n");
2672              if (i == 0 && do_showrest)              if (do_showcaprest || (i == 0 && do_showrest))
2673                {                {
2674                fprintf(outfile, " 0+ ");                fprintf(outfile, "%2d+ ", (int)i);
2675                (void)pchars(dbuffer + pmatch[i].rm_eo, len - pmatch[i].rm_eo,                (void)pchars(dbuffer + pmatch[i].rm_eo, len - pmatch[i].rm_eo,
2676                  outfile);                  outfile);
2677                fprintf(outfile, "\n");                fprintf(outfile, "\n");
# Line 2548  while (!done) Line 2721  while (!done)
2721    
2722        /* 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
2723        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
2724        for the recursion limit. */        for the recursion limit. The match limits are relevant only to the normal
2725          running of pcre_exec(), so disable the JIT optimization. This makes it
2726          possible to run the same set of tests with and without JIT externally
2727          requested. */
2728    
2729        if (find_match_limit)        if (find_match_limit)
2730          {          {
# Line 2557  while (!done) Line 2733  while (!done)
2733            extra = (pcre_extra *)malloc(sizeof(pcre_extra));            extra = (pcre_extra *)malloc(sizeof(pcre_extra));
2734            extra->flags = 0;            extra->flags = 0;
2735            }            }
2736            else extra->flags &= ~PCRE_EXTRA_EXECUTABLE_JIT;
2737    
2738          (void)check_match_limit(re, extra, bptr, len, start_offset,          (void)check_match_limit(re, extra, bptr, len, start_offset,
2739            options|g_notempty, use_offsets, use_size_offsets,            options|g_notempty, use_offsets, use_size_offsets,
# Line 2640  while (!done) Line 2817  while (!done)
2817              }              }
2818            }            }
2819    
2820            /* do_allcaps requests showing of all captures in the pattern, to check
2821            unset ones at the end. */
2822    
2823            if (do_allcaps)
2824              {
2825              new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count);
2826              count++;   /* Allow for full match */
2827              if (count * 2 > use_size_offsets) count = use_size_offsets/2;
2828              }
2829    
2830            /* Output the captured substrings */
2831    
2832          for (i = 0; i < count * 2; i += 2)          for (i = 0; i < count * 2; i += 2)
2833            {            {
2834            if (use_offsets[i] < 0)            if (use_offsets[i] < 0)
2835                {
2836                if (use_offsets[i] != -1)
2837                  fprintf(outfile, "ERROR: bad negative value %d for offset %d\n",
2838                    use_offsets[i], i);
2839                if (use_offsets[i+1] != -1)
2840                  fprintf(outfile, "ERROR: bad negative value %d for offset %d\n",
2841                    use_offsets[i+1], i+1);
2842              fprintf(outfile, "%2d: <unset>\n", i/2);              fprintf(outfile, "%2d: <unset>\n", i/2);
2843                }
2844            else            else
2845              {              {
2846              fprintf(outfile, "%2d: ", i/2);              fprintf(outfile, "%2d: ", i/2);
2847              (void)pchars(bptr + use_offsets[i],              (void)pchars(bptr + use_offsets[i],
2848                use_offsets[i+1] - use_offsets[i], outfile);                use_offsets[i+1] - use_offsets[i], outfile);
2849              fprintf(outfile, "\n");              fprintf(outfile, "\n");
2850              if (i == 0)              if (do_showcaprest || (i == 0 && do_showrest))
2851                {                {
2852                if (do_showrest)                fprintf(outfile, "%2d+ ", i/2);
2853                  {                (void)pchars(bptr + use_offsets[i+1], len - use_offsets[i+1],
2854                  fprintf(outfile, " 0+ ");                  outfile);
2855                  (void)pchars(bptr + use_offsets[i+1], len - use_offsets[i+1],                fprintf(outfile, "\n");
                   outfile);  
                 fprintf(outfile, "\n");  
                 }  
2856                }                }
2857              }              }
2858            }            }
# Line 2738  while (!done) Line 2932  while (!done)
2932                fprintf(outfile, "%2dL %s\n", i, stringlist[i]);                fprintf(outfile, "%2dL %s\n", i, stringlist[i]);
2933              if (stringlist[i] != NULL)              if (stringlist[i] != NULL)
2934                fprintf(outfile, "string list not terminated by NULL\n");                fprintf(outfile, "string list not terminated by NULL\n");
             /* free((void *)stringlist); */  
2935              pcre_free_substring_list(stringlist);              pcre_free_substring_list(stringlist);
2936              }              }
2937            }            }
# Line 2765  while (!done) Line 2958  while (!done)
2958        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
2959        string - that was checked before setting g_notempty.        string - that was checked before setting g_notempty.
2960    
2961        Complication arises in the case when the newline option is "any" or        Complication arises in the case when the newline convention is "any",
2962        "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
2963        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,
2964        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
2965        Fudge the offset value to achieve this.        pcre_exec(). Fudge the offset value to achieve this. We check for a
2966          newline setting in the pattern; if none was set, use pcre_config() to
2967          find the default.
2968    
2969        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
2970        character, not one byte. */        character, not one byte. */
# Line 2794  while (!done) Line 2989  while (!done)
2989                      (d == -1)? PCRE_NEWLINE_ANY : 0;                      (d == -1)? PCRE_NEWLINE_ANY : 0;
2990              }              }
2991            if (((obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANY ||            if (((obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANY ||
2992                   (obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_CRLF ||
2993                 (obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANYCRLF)                 (obits & PCRE_NEWLINE_BITS) == PCRE_NEWLINE_ANYCRLF)
2994                &&                &&
2995                start_offset < len - 1 &&                start_offset < len - 1 &&
# Line 2804  while (!done) Line 3000  while (!done)
3000              {              {
3001              while (start_offset + onechar < len)              while (start_offset + onechar < len)
3002                {                {
3003                int tb = bptr[start_offset+onechar];                if ((bptr[start_offset+onechar] & 0xc0) != 0x80) break;
3004                if (tb <= 127) break;                onechar++;
               tb &= 0xc0;  
               if (tb != 0 && tb != 0xc0) onechar++;  
3005                }                }
3006              }              }
3007            use_offsets[1] = start_offset + onechar;            use_offsets[1] = start_offset + onechar;
3008            }            }
3009          else          else
3010            {            {
3011            if (count == PCRE_ERROR_NOMATCH)            switch(count)
3012              {              {
3013                case PCRE_ERROR_NOMATCH:
3014              if (gmatched == 0)              if (gmatched == 0)
3015                {                {
3016                if (markptr == NULL) fprintf(outfile, "No match\n");                if (markptr == NULL) fprintf(outfile, "No match\n");
3017                  else fprintf(outfile, "No match, mark = %s\n", markptr);                  else fprintf(outfile, "No match, mark = %s\n", markptr);
3018                }                }
3019                break;
3020    
3021                case PCRE_ERROR_BADUTF8:
3022                case PCRE_ERROR_SHORTUTF8:
3023                fprintf(outfile, "Error %d (%s UTF-8 string)", count,
3024                  (count == PCRE_ERROR_BADUTF8)? "bad" : "short");
3025                if (use_size_offsets >= 2)
3026                  fprintf(outfile, " offset=%d reason=%d", use_offsets[0],
3027                    use_offsets[1]);
3028                fprintf(outfile, "\n");
3029                break;
3030    
3031                default:
3032                if (count < 0 && (-count) < sizeof(errtexts)/sizeof(const char *))
3033                  fprintf(outfile, "Error %d (%s)\n", count, errtexts[-count]);
3034                else
3035                  fprintf(outfile, "Error %d (Unexpected value)\n", count);
3036                break;
3037              }              }
3038            else fprintf(outfile, "Error %d\n", count);  
3039            break;  /* Out of the /g loop */            break;  /* Out of the /g loop */
3040            }            }
3041          }          }
# Line 2869  while (!done) Line 3082  while (!done)
3082  #endif  #endif
3083    
3084    if (re != NULL) new_free(re);    if (re != NULL) new_free(re);
3085    if (extra != NULL) new_free(extra);    if (extra != NULL) pcre_free_study(extra);
3086    if (locale_set)    if (locale_set)
3087      {      {
3088      new_free((void *)tables);      new_free((void *)tables);
3089      setlocale(LC_CTYPE, "C");      setlocale(LC_CTYPE, "C");
3090      locale_set = 0;      locale_set = 0;
3091      }      }
3092      if (jit_stack != NULL)
3093        {
3094        pcre_jit_stack_free(jit_stack);
3095        jit_stack = NULL;
3096        }
3097    }    }
3098    
3099  if (infile == stdin) fprintf(outfile, "\n");  if (infile == stdin) fprintf(outfile, "\n");

Legend:
Removed from v.545  
changed lines
  Added in v.735

  ViewVC Help
Powered by ViewVC 1.1.5