/[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 612 by ph10, Sat Jul 2 15:20:59 2011 UTC revision 667 by ph10, Mon Aug 22 14:57:32 2011 UTC
# Line 112  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 189  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 207  static const char *errtexts[] = { Line 210  static const char *errtexts[] = {
210    "magic number missing",    "magic number missing",
211    "unknown opcode - pattern overwritten?",    "unknown opcode - pattern overwritten?",
212    "no more memory",    "no more memory",
213    NULL,  /* never returned by pcre_exec() or pcre_dfa_exec() */    NULL,  /* never returned by pcre_exec() or pcre_dfa_exec() */
214    "match limit exceeded",    "match limit exceeded",
215    "callout error code",    "callout error code",
216    NULL,  /* BADUTF8 is handled specially */    NULL,  /* BADUTF8 is handled specially */
# Line 220  static const char *errtexts[] = { Line 223  static const char *errtexts[] = {
223    "backreference condition or recursion test not supported for DFA matching",    "backreference condition or recursion test not supported for DFA matching",
224    "match limit not supported for DFA matching",    "match limit not supported for DFA matching",
225    "workspace size exceeded in DFA matching",    "workspace size exceeded in DFA matching",
226    "too much recursion for DFA matching",    "too much recursion for DFA matching",
227    "recursion limit exceeded",    "recursion limit exceeded",
228    "not used - internal error",    "not used - internal error",
229    "invalid combination of newline options",    "invalid combination of newline options",
230    "bad offset value",    "bad offset value",
231    NULL  /* SHORTUTF8 is handled specially */    NULL,  /* SHORTUTF8 is handled specially */
232      "nested recursion at the same subject position"
233  };  };
234    
235    
236  /*************************************************  /*************************************************
237  *         Alternate character tables             *  *         Alternate character tables             *
# Line 577  return sys_errlist[n]; Line 581  return sys_errlist[n];
581  #endif /* HAVE_STRERROR */  #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  /*************************************************  /*************************************************
# Line 959  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 978  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 997  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 1186  printf("  -p       use POSIX interface\n Line 1204  printf("  -p       use POSIX interface\n
1204  #endif  #endif
1205  printf("  -q       quiet: do not output PCRE version number at start\n");  printf("  -q       quiet: do not output PCRE version number at start\n");
1206  printf("  -S <n>   set stack size to <n> megabytes\n");  printf("  -S <n>   set stack size to <n> megabytes\n");
1207  printf("  -s       force each pattern to be studied\n"  printf("  -s       force each pattern to be studied at basic level\n"
1208           "  -s+      force each pattern to be studied, using JIT if available\n"
1209         "  -t       time compilation and execution\n");         "  -t       time compilation and execution\n");
1210  printf("  -t <n>   time compilation and execution, repeating <n> times\n");  printf("  -t <n>   time compilation and execution, repeating <n> times\n");
1211  printf("  -tm      time execution (matching) only\n");  printf("  -tm      time execution (matching) only\n");
# Line 1214  int timeit = 0; Line 1233  int timeit = 0;
1233  int timeitm = 0;  int timeitm = 0;
1234  int showinfo = 0;  int showinfo = 0;
1235  int showstore = 0;  int showstore = 0;
1236  int force_study = 0;  int force_study = -1;
1237    int force_study_options = 0;
1238  int quiet = 0;  int quiet = 0;
1239  int size_offsets = 45;  int size_offsets = 45;
1240  int size_offsets_max;  int size_offsets_max;
# Line 1228  int all_use_dfa = 0; Line 1248  int all_use_dfa = 0;
1248  int yield = 0;  int yield = 0;
1249  int stack_size;  int stack_size;
1250    
1251    pcre_jit_stack *jit_stack = NULL;
1252    
1253    
1254  /* 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
1255  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. */
1256    
# Line 1264  while (argc > 1 && argv[op][0] == '-') Line 1287  while (argc > 1 && argv[op][0] == '-')
1287    unsigned char *endptr;    unsigned char *endptr;
1288    
1289    if (strcmp(argv[op], "-m") == 0) showstore = 1;    if (strcmp(argv[op], "-m") == 0) showstore = 1;
1290    else if (strcmp(argv[op], "-s") == 0) force_study = 1;    else if (strcmp(argv[op], "-s") == 0) force_study = 0;
1291      else if (strcmp(argv[op], "-s+") == 0)
1292        {
1293        force_study = 1;
1294        force_study_options = PCRE_STUDY_JIT_COMPILE;
1295        }
1296    else if (strcmp(argv[op], "-q") == 0) quiet = 1;    else if (strcmp(argv[op], "-q") == 0) quiet = 1;
1297    else if (strcmp(argv[op], "-b") == 0) debug = 1;    else if (strcmp(argv[op], "-b") == 0) debug = 1;
1298    else if (strcmp(argv[op], "-i") == 0) showinfo = 1;    else if (strcmp(argv[op], "-i") == 0) showinfo = 1;
# Line 1298  while (argc > 1 && argv[op][0] == '-') Line 1326  while (argc > 1 && argv[op][0] == '-')
1326        ((stack_size = get_value((unsigned char *)argv[op+1], &endptr)),        ((stack_size = get_value((unsigned char *)argv[op+1], &endptr)),
1327          *endptr == 0))          *endptr == 0))
1328      {      {
1329  #if defined(_WIN32) || defined(WIN32)  #if defined(_WIN32) || defined(WIN32) || defined(__minix)
1330      printf("PCRE: -S not supported on this OS\n");      printf("PCRE: -S not supported on this OS\n");
1331      exit(1);      exit(1);
1332  #else  #else
# Line 1329  while (argc > 1 && argv[op][0] == '-') Line 1357  while (argc > 1 && argv[op][0] == '-')
1357      printf("  %sUTF-8 support\n", rc? "" : "No ");      printf("  %sUTF-8 support\n", rc? "" : "No ");
1358      (void)pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &rc);      (void)pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &rc);
1359      printf("  %sUnicode properties support\n", rc? "" : "No ");      printf("  %sUnicode properties support\n", rc? "" : "No ");
1360        (void)pcre_config(PCRE_CONFIG_JIT, &rc);
1361        printf("  %sJust-in-time compiler support\n", rc? "" : "No ");
1362      (void)pcre_config(PCRE_CONFIG_NEWLINE, &rc);      (void)pcre_config(PCRE_CONFIG_NEWLINE, &rc);
1363      /* Note that these values are always the ASCII values, even      /* Note that these values are always the ASCII values, even
1364      in EBCDIC environments. CR is 13 and NL is 10. */      in EBCDIC environments. CR is 13 and NL is 10. */
# Line 1434  while (!done) Line 1464  while (!done)
1464    const unsigned char *tables = NULL;    const unsigned char *tables = NULL;
1465    unsigned long int true_size, true_study_size = 0;    unsigned long int true_size, true_study_size = 0;
1466    size_t size, regex_gotten_store;    size_t size, regex_gotten_store;
1467      int do_allcaps = 0;
1468    int do_mark = 0;    int do_mark = 0;
1469    int do_study = 0;    int do_study = 0;
1470    int no_force_study = 0;    int no_force_study = 0;
1471    int do_debug = debug;    int do_debug = debug;
1472    int do_G = 0;    int do_G = 0;
1473    int do_g = 0;    int do_g = 0;
1474    int do_showinfo = showinfo;    int do_showinfo = showinfo;
1475    int do_showrest = 0;    int do_showrest = 0;
1476      int do_showcaprest = 0;
1477    int do_flip = 0;    int do_flip = 0;
1478    int erroroffset, len, delimiter, poffset;    int erroroffset, len, delimiter, poffset;
1479    
# Line 1527  while (!done) Line 1559  while (!done)
1559          {          {
1560          FAIL_READ:          FAIL_READ:
1561          fprintf(outfile, "Failed to read data from %s\n", p);          fprintf(outfile, "Failed to read data from %s\n", p);
1562          if (extra != NULL) new_free(extra);          if (extra != NULL) pcre_free_study(extra);
1563          if (re != NULL) new_free(re);          if (re != NULL) new_free(re);
1564          fclose(f);          fclose(f);
1565          continue;          continue;
# Line 1593  while (!done) Line 1625  while (!done)
1625    /* Look for options after final delimiter */    /* Look for options after final delimiter */
1626    
1627    options = 0;    options = 0;
   study_options = 0;  
1628    log_store = showstore;  /* default from command line */    log_store = showstore;  /* default from command line */
1629    
1630    while (*pp != 0)    while (*pp != 0)
# Line 1607  while (!done) Line 1638  while (!done)
1638        case 's': options |= PCRE_DOTALL; break;        case 's': options |= PCRE_DOTALL; break;
1639        case 'x': options |= PCRE_EXTENDED; break;        case 'x': options |= PCRE_EXTENDED; break;
1640    
1641        case '+': do_showrest = 1; break;        case '+':
1642          if (do_showrest) do_showcaprest = 1; else do_showrest = 1;
1643          break;
1644    
1645          case '=': do_allcaps = 1; break;
1646        case 'A': options |= PCRE_ANCHORED; break;        case 'A': options |= PCRE_ANCHORED; break;
1647        case 'B': do_debug = 1; break;        case 'B': do_debug = 1; break;
1648        case 'C': options |= PCRE_AUTO_CALLOUT; break;        case 'C': options |= PCRE_AUTO_CALLOUT; break;
# Line 1625  while (!done) Line 1660  while (!done)
1660        case 'P': do_posix = 1; break;        case 'P': do_posix = 1; break;
1661  #endif  #endif
1662    
1663        case 'S':        case 'S':
1664        if (do_study == 0) do_study = 1; else        if (do_study == 0)
1665            {
1666            do_study = 1;
1667            if (*pp == '+')
1668              {
1669              study_options |= PCRE_STUDY_JIT_COMPILE;
1670              pp++;
1671              }
1672            }
1673          else
1674          {          {
1675          do_study = 0;          do_study = 0;
1676          no_force_study = 1;          no_force_study = 1;
1677          }          }
1678        break;        break;
1679    
1680        case 'U': options |= PCRE_UNGREEDY; break;        case 'U': options |= PCRE_UNGREEDY; break;
# Line 1817  while (!done) Line 1861  while (!done)
1861      regex_gotten_store = gotten_store;      regex_gotten_store = gotten_store;
1862    
1863      /* If -s or /S was present, study the regex to generate additional info to      /* If -s or /S was present, study the regex to generate additional info to
1864      help with the matching, unless the pattern has the SS option, which      help with the matching, unless the pattern has the SS option, which
1865      suppresses the effect of /S (used for a few test patterns where studying is      suppresses the effect of /S (used for a few test patterns where studying is
1866      never sensible). */      never sensible). */
1867    
1868      if (do_study || (force_study && !no_force_study))      if (do_study || (force_study >= 0 && !no_force_study))
1869        {        {
1870        if (timeit > 0)        if (timeit > 0)
1871          {          {
# Line 1829  while (!done) Line 1873  while (!done)
1873          clock_t time_taken;          clock_t time_taken;
1874          clock_t start_time = clock();          clock_t start_time = clock();
1875          for (i = 0; i < timeit; i++)          for (i = 0; i < timeit; i++)
1876            extra = pcre_study(re, study_options, &error);            extra = pcre_study(re, study_options | force_study_options, &error);
1877          time_taken = clock() - start_time;          time_taken = clock() - start_time;
1878          if (extra != NULL) free(extra);          if (extra != NULL) pcre_free_study(extra);
1879          fprintf(outfile, "  Study time %.4f milliseconds\n",          fprintf(outfile, "  Study time %.4f milliseconds\n",
1880            (((double)time_taken * 1000.0) / (double)timeit) /            (((double)time_taken * 1000.0) / (double)timeit) /
1881              (double)CLOCKS_PER_SEC);              (double)CLOCKS_PER_SEC);
1882          }          }
1883        extra = pcre_study(re, study_options, &error);        extra = pcre_study(re, study_options | force_study_options, &error);
1884        if (error != NULL)        if (error != NULL)
1885          fprintf(outfile, "Failed to study: %s\n", error);          fprintf(outfile, "Failed to study: %s\n", error);
1886        else if (extra != NULL)        else if (extra != NULL)
# Line 2059  while (!done) Line 2103  while (!done)
2103        /* 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
2104        value, but it varies, depending on the computer architecture, and        value, but it varies, depending on the computer architecture, and
2105        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
2106        flipped.) If study was forced by an external -s, don't show this        flipped.) If study was forced by an external -s, don't show this
2107        information unless -i or -d was also present. This means that, except        information unless -i or -d was also present. This means that, except
2108        when auto-callouts are involved, the output from runs with and without        when auto-callouts are involved, the output from runs with and without
2109        -s should be identical. */        -s should be identical. */
2110    
2111        if (do_study || (force_study && showinfo && !no_force_study))        if (do_study || (force_study >= 0 && showinfo && !no_force_study))
2112          {          {
2113          if (extra == NULL)          if (extra == NULL)
2114            fprintf(outfile, "Study returned NULL\n");            fprintf(outfile, "Study returned NULL\n");
# Line 2108  while (!done) Line 2152  while (!done)
2152              fprintf(outfile, "\n");              fprintf(outfile, "\n");
2153              }              }
2154            }            }
2155    
2156            /* Show this only if the JIT was set by /S, not by -s. */
2157    
2158            if ((study_options & PCRE_STUDY_JIT_COMPILE) != 0)
2159              {
2160              int jit;
2161              new_info(re, extra, PCRE_INFO_JIT, &jit);
2162              if (jit)
2163                fprintf(outfile, "JIT study was successful\n");
2164              else
2165    #ifdef SUPPORT_JIT
2166                fprintf(outfile, "JIT study was not successful\n");
2167    #else
2168                fprintf(outfile, "JIT support is not available in this version of PCRE\n");
2169    #endif
2170              }
2171          }          }
2172        }        }
2173    
# Line 2143  while (!done) Line 2203  while (!done)
2203          else          else
2204            {            {
2205            fprintf(outfile, "Compiled pattern written to %s\n", to_file);            fprintf(outfile, "Compiled pattern written to %s\n", to_file);
2206    
2207            /* If there is study data, write it, but verify the writing only            /* If there is study data, write it. */
2208            if the studying was requested by /S, not just by -s. */  
   
2209            if (extra != NULL)            if (extra != NULL)
2210              {              {
2211              if (fwrite(extra->study_data, 1, true_study_size, f) <              if (fwrite(extra->study_data, 1, true_study_size, f) <
# Line 2162  while (!done) Line 2221  while (!done)
2221          }          }
2222    
2223        new_free(re);        new_free(re);
2224        if (extra != NULL) new_free(extra);        if (extra != NULL) pcre_free_study(extra);
2225        if (locale_set)        if (locale_set)
2226          {          {
2227          new_free((void *)tables);          new_free((void *)tables);
# Line 2204  while (!done) Line 2263  while (!done)
2263    
2264      pcre_callout = callout;      pcre_callout = callout;
2265      first_callout = 1;      first_callout = 1;
2266        last_callout_mark = NULL;
2267      callout_extra = 0;      callout_extra = 0;
2268      callout_count = 0;      callout_count = 0;
2269      callout_fail_count = 999999;      callout_fail_count = 999999;
# Line 2428  while (!done) Line 2488  while (!done)
2488            getnamesptr = npp;            getnamesptr = npp;
2489            }            }
2490          continue;          continue;
2491    
2492            case 'J':
2493            while(isdigit(*p)) n = n * 10 + *p++ - '0';
2494            if (extra != NULL
2495                && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0
2496                && extra->executable_jit != NULL)
2497              {
2498              if (jit_stack != NULL) pcre_jit_stack_free(jit_stack);
2499              jit_stack = pcre_jit_stack_alloc(1, n * 1024);
2500              pcre_assign_jit_callback(extra, jit_callback, jit_stack);
2501              }
2502            continue;
2503    
2504          case 'L':          case 'L':
2505          getlist = 1;          getlist = 1;
# Line 2587  while (!done) Line 2659  while (!done)
2659              (void)pchars(dbuffer + pmatch[i].rm_so,              (void)pchars(dbuffer + pmatch[i].rm_so,
2660                pmatch[i].rm_eo - pmatch[i].rm_so, outfile);                pmatch[i].rm_eo - pmatch[i].rm_so, outfile);
2661              fprintf(outfile, "\n");              fprintf(outfile, "\n");
2662              if (i == 0 && do_showrest)              if (do_showcaprest || (i == 0 && do_showrest))
2663                {                {
2664                fprintf(outfile, " 0+ ");                fprintf(outfile, "%2d+ ", (int)i);
2665                (void)pchars(dbuffer + pmatch[i].rm_eo, len - pmatch[i].rm_eo,                (void)pchars(dbuffer + pmatch[i].rm_eo, len - pmatch[i].rm_eo,
2666                  outfile);                  outfile);
2667                fprintf(outfile, "\n");                fprintf(outfile, "\n");
# Line 2639  while (!done) Line 2711  while (!done)
2711    
2712        /* 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
2713        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
2714        for the recursion limit. */        for the recursion limit. The match limits are relevant only to the normal
2715          running of pcre_exec(), so disable the JIT optimization. This makes it
2716          possible to run the same set of tests with and without JIT externally
2717          requested. */
2718    
2719        if (find_match_limit)        if (find_match_limit)
2720          {          {
# Line 2648  while (!done) Line 2723  while (!done)
2723            extra = (pcre_extra *)malloc(sizeof(pcre_extra));            extra = (pcre_extra *)malloc(sizeof(pcre_extra));
2724            extra->flags = 0;            extra->flags = 0;
2725            }            }
2726            else extra->flags &= ~PCRE_EXTRA_EXECUTABLE_JIT;
2727    
2728          (void)check_match_limit(re, extra, bptr, len, start_offset,          (void)check_match_limit(re, extra, bptr, len, start_offset,
2729            options|g_notempty, use_offsets, use_size_offsets,            options|g_notempty, use_offsets, use_size_offsets,
2730            PCRE_EXTRA_MATCH_LIMIT, &(extra->match_limit),            PCRE_EXTRA_MATCH_LIMIT, &(extra->match_limit),
# Line 2731  while (!done) Line 2807  while (!done)
2807              }              }
2808            }            }
2809    
2810            /* do_allcaps requests showing of all captures in the pattern, to check
2811            unset ones at the end. */
2812    
2813            if (do_allcaps)
2814              {
2815              new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count);
2816              count++;   /* Allow for full match */
2817              if (count * 2 > use_size_offsets) count = use_size_offsets/2;
2818              }
2819    
2820            /* Output the captured substrings */
2821    
2822          for (i = 0; i < count * 2; i += 2)          for (i = 0; i < count * 2; i += 2)
2823            {            {
2824            if (use_offsets[i] < 0)            if (use_offsets[i] < 0)
2825                {
2826                if (use_offsets[i] != -1)
2827                  fprintf(outfile, "ERROR: bad negative value %d for offset %d\n",
2828                    use_offsets[i], i);
2829                if (use_offsets[i+1] != -1)
2830                  fprintf(outfile, "ERROR: bad negative value %d for offset %d\n",
2831                    use_offsets[i+1], i+1);
2832              fprintf(outfile, "%2d: <unset>\n", i/2);              fprintf(outfile, "%2d: <unset>\n", i/2);
2833                }
2834            else            else
2835              {              {
2836              fprintf(outfile, "%2d: ", i/2);              fprintf(outfile, "%2d: ", i/2);
2837              (void)pchars(bptr + use_offsets[i],              (void)pchars(bptr + use_offsets[i],
2838                use_offsets[i+1] - use_offsets[i], outfile);                use_offsets[i+1] - use_offsets[i], outfile);
2839              fprintf(outfile, "\n");              fprintf(outfile, "\n");
2840              if (i == 0)              if (do_showcaprest || (i == 0 && do_showrest))
2841                {                {
2842                if (do_showrest)                fprintf(outfile, "%2d+ ", i/2);
2843                  {                (void)pchars(bptr + use_offsets[i+1], len - use_offsets[i+1],
2844                  fprintf(outfile, " 0+ ");                  outfile);
2845                  (void)pchars(bptr + use_offsets[i+1], len - use_offsets[i+1],                fprintf(outfile, "\n");
                   outfile);  
                 fprintf(outfile, "\n");  
                 }  
2846                }                }
2847              }              }
2848            }            }
# Line 2829  while (!done) Line 2922  while (!done)
2922                fprintf(outfile, "%2dL %s\n", i, stringlist[i]);                fprintf(outfile, "%2dL %s\n", i, stringlist[i]);
2923              if (stringlist[i] != NULL)              if (stringlist[i] != NULL)
2924                fprintf(outfile, "string list not terminated by NULL\n");                fprintf(outfile, "string list not terminated by NULL\n");
             /* free((void *)stringlist); */  
2925              pcre_free_substring_list(stringlist);              pcre_free_substring_list(stringlist);
2926              }              }
2927            }            }
# Line 2907  while (!done) Line 2999  while (!done)
2999          else          else
3000            {            {
3001            switch(count)            switch(count)
3002              {              {
3003              case PCRE_ERROR_NOMATCH:              case PCRE_ERROR_NOMATCH:
3004              if (gmatched == 0)              if (gmatched == 0)
3005                {                {
# Line 2915  while (!done) Line 3007  while (!done)
3007                  else fprintf(outfile, "No match, mark = %s\n", markptr);                  else fprintf(outfile, "No match, mark = %s\n", markptr);
3008                }                }
3009              break;              break;
3010    
3011              case PCRE_ERROR_BADUTF8:              case PCRE_ERROR_BADUTF8:
3012              case PCRE_ERROR_SHORTUTF8:              case PCRE_ERROR_SHORTUTF8:
3013              fprintf(outfile, "Error %d (%s UTF-8 string)", count,              fprintf(outfile, "Error %d (%s UTF-8 string)", count,
3014                (count == PCRE_ERROR_BADUTF8)? "bad" : "short");                (count == PCRE_ERROR_BADUTF8)? "bad" : "short");
3015              if (use_size_offsets >= 2)              if (use_size_offsets >= 2)
3016                fprintf(outfile, " offset=%d reason=%d", use_offsets[0],                fprintf(outfile, " offset=%d reason=%d", use_offsets[0],
3017                  use_offsets[1]);                  use_offsets[1]);
3018              fprintf(outfile, "\n");              fprintf(outfile, "\n");
3019              break;              break;
3020    
3021              default:              default:
3022              if (count < 0 && (-count) < sizeof(errtexts)/sizeof(const char *))              if (count < 0 && (-count) < sizeof(errtexts)/sizeof(const char *))
3023                fprintf(outfile, "Error %d (%s)\n", count, errtexts[-count]);                fprintf(outfile, "Error %d (%s)\n", count, errtexts[-count]);
3024              else              else
3025                fprintf(outfile, "Error %d (Unexpected value)\n", count);                fprintf(outfile, "Error %d (Unexpected value)\n", count);
3026              break;              break;
3027              }              }
3028    
3029            break;  /* Out of the /g loop */            break;  /* Out of the /g loop */
3030            }            }
3031          }          }
# Line 2980  while (!done) Line 3072  while (!done)
3072  #endif  #endif
3073    
3074    if (re != NULL) new_free(re);    if (re != NULL) new_free(re);
3075    if (extra != NULL) new_free(extra);    if (extra != NULL) pcre_free_study(extra);
3076    if (locale_set)    if (locale_set)
3077      {      {
3078      new_free((void *)tables);      new_free((void *)tables);
3079      setlocale(LC_CTYPE, "C");      setlocale(LC_CTYPE, "C");
3080      locale_set = 0;      locale_set = 0;
3081      }      }
3082      if (jit_stack != NULL)
3083        {
3084        pcre_jit_stack_free(jit_stack);
3085        jit_stack = NULL;
3086        }
3087    }    }
3088    
3089  if (infile == stdin) fprintf(outfile, "\n");  if (infile == stdin) fprintf(outfile, "\n");

Legend:
Removed from v.612  
changed lines
  Added in v.667

  ViewVC Help
Powered by ViewVC 1.1.5