/[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

code/trunk/pcretest.c revision 676 by ph10, Sat Aug 27 15:53:04 2011 UTC code/branches/pcre16/pcretest.c revision 801 by ph10, Mon Dec 12 16:23:37 2011 UTC
# Line 118  external symbols to prevent clashes. */ Line 118  external symbols to prevent clashes. */
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
 #define _pcre_utf8_char_sizes  utf8_char_sizes  
121  #define _pcre_utt              utt  #define _pcre_utt              utt
122  #define _pcre_utt_size         utt_size  #define _pcre_utt_size         utt_size
123  #define _pcre_utt_names        utt_names  #define _pcre_utt_names        utt_names
# Line 191  static int locale_set = 0; Line 190  static int locale_set = 0;
190  static int show_malloc;  static int show_malloc;
191  static int use_utf8;  static int use_utf8;
192  static size_t gotten_store;  static size_t gotten_store;
193    static size_t first_gotten_store = 0;
194  static const unsigned char *last_callout_mark = NULL;  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    
198  static int buffer_size = 50000;  static int buffer_size = 50000;
199  static uschar *buffer = NULL;  static pcre_uint8 *buffer = NULL;
200  static uschar *dbuffer = NULL;  static pcre_uint8 *dbuffer = NULL;
201  static uschar *pbuffer = NULL;  static pcre_uint8 *pbuffer = NULL;
202    
203  /* Textual explanations for runtime error codes */  /* Textual explanations for runtime error codes */
204    
# Line 230  static const char *errtexts[] = { Line 230  static const char *errtexts[] = {
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",    "nested recursion at the same subject position",
233    "JIT stack limit reached"    "JIT stack limit reached"
234  };  };
235    
236    
# Line 615  Returns:       pointer to the start of n Line 615  Returns:       pointer to the start of n
615                 NULL if no data read and EOF reached                 NULL if no data read and EOF reached
616  */  */
617    
618  static uschar *  static pcre_uint8 *
619  extend_inputline(FILE *f, uschar *start, const char *prompt)  extend_inputline(FILE *f, pcre_uint8 *start, const char *prompt)
620  {  {
621  uschar *here = start;  pcre_uint8 *here = start;
622    
623  for (;;)  for (;;)
624    {    {
# Line 665  for (;;) Line 665  for (;;)
665    else    else
666      {      {
667      int new_buffer_size = 2*buffer_size;      int new_buffer_size = 2*buffer_size;
668      uschar *new_buffer = (unsigned char *)malloc(new_buffer_size);      pcre_uint8 *new_buffer = (unsigned char *)malloc(new_buffer_size);
669      uschar *new_dbuffer = (unsigned char *)malloc(new_buffer_size);      pcre_uint8 *new_dbuffer = (unsigned char *)malloc(new_buffer_size);
670      uschar *new_pbuffer = (unsigned char *)malloc(new_buffer_size);      pcre_uint8 *new_pbuffer = (unsigned char *)malloc(new_buffer_size);
671    
672      if (new_buffer == NULL || new_dbuffer == NULL || new_pbuffer == NULL)      if (new_buffer == NULL || new_dbuffer == NULL || new_pbuffer == NULL)
673        {        {
# Line 809  Returns:     number of characters placed Line 809  Returns:     number of characters placed
809  #if !defined NOUTF8  #if !defined NOUTF8
810    
811  static int  static int
812  ord2utf8(int cvalue, uschar *utf8bytes)  ord2utf8(int cvalue, pcre_uint8 *utf8bytes)
813  {  {
814  register int i, j;  register int i, j;
815  for (i = 0; i < utf8_table1_size; i++)  for (i = 0; i < utf8_table1_size; i++)
# Line 999  return (cb->callout_number != callout_fa Line 999  return (cb->callout_number != callout_fa
999  *************************************************/  *************************************************/
1000    
1001  /* Alternative malloc function, to test functionality and save the size of a  /* Alternative malloc function, to test functionality and save the size of a
1002  compiled re. The show_malloc variable is set only during matching. */  compiled re, which is the first store request that pcre_compile() makes. The
1003    show_malloc variable is set only during matching. */
1004    
1005  static void *new_malloc(size_t size)  static void *new_malloc(size_t size)
1006  {  {
1007  void *block = malloc(size);  void *block = malloc(size);
1008  gotten_store = size;  gotten_store = size;
1009    if (first_gotten_store == 0) first_gotten_store = size;
1010  if (show_malloc)  if (show_malloc)
1011    fprintf(outfile, "malloc       %3d %p\n", (int)size, block);    fprintf(outfile, "malloc       %3d %p\n", (int)size, block);
1012  return block;  return block;
# Line 1051  if ((rc = pcre_fullinfo(re, study, optio Line 1053  if ((rc = pcre_fullinfo(re, study, optio
1053    
1054    
1055  /*************************************************  /*************************************************
 *      Check for supported JIT architecture      *  
 *************************************************/  
   
 /* If it won't JIT-compile a very simple regex, return FALSE. */  
   
 static int check_jit_arch(void)  
 {  
 const char *error;  
 int erroffset, rc;  
 pcre *re = pcre_compile("abc", 0, &error, &erroffset, NULL);  
 pcre_extra *extra = pcre_study(re, PCRE_STUDY_JIT_COMPILE, &error);  
 rc = extra != NULL && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 &&  
   extra->executable_jit != NULL;  
 pcre_free_study(extra);  
 free(re);  
 return rc;  
 }  
   
   
 /*************************************************  
1056  *         Byte flipping function                 *  *         Byte flipping function                 *
1057  *************************************************/  *************************************************/
1058    
# Line 1092  return ((value & 0x000000ff) << 24) | Line 1074  return ((value & 0x000000ff) << 24) |
1074  *************************************************/  *************************************************/
1075    
1076  static int  static int
1077  check_match_limit(pcre *re, pcre_extra *extra, uschar *bptr, int len,  check_match_limit(pcre *re, pcre_extra *extra, pcre_uint8 *bptr, int len,
1078    int start_offset, int options, int *use_offsets, int use_size_offsets,    int start_offset, int options, int *use_offsets, int use_size_offsets,
1079    int flag, unsigned long int *limit, int errnumber, const char *msg)    int flag, unsigned long int *limit, int errnumber, const char *msg)
1080  {  {
# Line 1152  Returns:    < 0, = 0, or > 0, according Line 1134  Returns:    < 0, = 0, or > 0, according
1134  */  */
1135    
1136  static int  static int
1137  strncmpic(uschar *s, uschar *t, int n)  strncmpic(pcre_uint8 *s, pcre_uint8 *t, int n)
1138  {  {
1139  while (n--)  while (n--)
1140    {    {
# Line 1179  Returns:      appropriate PCRE_NEWLINE_x Line 1161  Returns:      appropriate PCRE_NEWLINE_x
1161  */  */
1162    
1163  static int  static int
1164  check_newline(uschar *p, FILE *f)  check_newline(pcre_uint8 *p, FILE *f)
1165  {  {
1166  if (strncmpic(p, (uschar *)"cr>", 3) == 0) return PCRE_NEWLINE_CR;  if (strncmpic(p, (pcre_uint8 *)"cr>", 3) == 0) return PCRE_NEWLINE_CR;
1167  if (strncmpic(p, (uschar *)"lf>", 3) == 0) return PCRE_NEWLINE_LF;  if (strncmpic(p, (pcre_uint8 *)"lf>", 3) == 0) return PCRE_NEWLINE_LF;
1168  if (strncmpic(p, (uschar *)"crlf>", 5) == 0) return PCRE_NEWLINE_CRLF;  if (strncmpic(p, (pcre_uint8 *)"crlf>", 5) == 0) return PCRE_NEWLINE_CRLF;
1169  if (strncmpic(p, (uschar *)"anycrlf>", 8) == 0) return PCRE_NEWLINE_ANYCRLF;  if (strncmpic(p, (pcre_uint8 *)"anycrlf>", 8) == 0) return PCRE_NEWLINE_ANYCRLF;
1170  if (strncmpic(p, (uschar *)"any>", 4) == 0) return PCRE_NEWLINE_ANY;  if (strncmpic(p, (pcre_uint8 *)"any>", 4) == 0) return PCRE_NEWLINE_ANY;
1171  if (strncmpic(p, (uschar *)"bsr_anycrlf>", 12) == 0) return PCRE_BSR_ANYCRLF;  if (strncmpic(p, (pcre_uint8 *)"bsr_anycrlf>", 12) == 0) return PCRE_BSR_ANYCRLF;
1172  if (strncmpic(p, (uschar *)"bsr_unicode>", 12) == 0) return PCRE_BSR_UNICODE;  if (strncmpic(p, (pcre_uint8 *)"bsr_unicode>", 12) == 0) return PCRE_BSR_UNICODE;
1173  fprintf(f, "Unknown newline type at: <%s\n", p);  fprintf(f, "Unknown newline type at: <%s\n", p);
1174  return 0;  return 0;
1175  }  }
# Line 1275  pcre_jit_stack *jit_stack = NULL; Line 1257  pcre_jit_stack *jit_stack = NULL;
1257  /* 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
1258  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. */
1259    
1260  uschar copynames[1024];  pcre_uchar copynames[1024];
1261  uschar getnames[1024];  pcre_uchar getnames[1024];
1262    
1263  uschar *copynamesptr;  pcre_uchar *copynamesptr;
1264  uschar *getnamesptr;  pcre_uchar *getnamesptr;
1265    
1266  /* Get buffers from malloc() so that Electric Fence will check their misuse  /* Get buffers from malloc() so that Electric Fence will check their misuse
1267  when I am debugging. They grow automatically when very long lines are read. */  when I am debugging. They grow automatically when very long lines are read. */
1268    
1269  buffer = (unsigned char *)malloc(buffer_size);  buffer = (pcre_uint8 *)malloc(buffer_size);
1270  dbuffer = (unsigned char *)malloc(buffer_size);  dbuffer = (pcre_uint8 *)malloc(buffer_size);
1271  pbuffer = (unsigned char *)malloc(buffer_size);  pbuffer = (pcre_uint8 *)malloc(buffer_size);
1272    
1273  /* The outfile variable is static so that new_malloc can use it. */  /* The outfile variable is static so that new_malloc can use it. */
1274    
# Line 1309  while (argc > 1 && argv[op][0] == '-') Line 1291  while (argc > 1 && argv[op][0] == '-')
1291    
1292    if (strcmp(argv[op], "-m") == 0) showstore = 1;    if (strcmp(argv[op], "-m") == 0) showstore = 1;
1293    else if (strcmp(argv[op], "-s") == 0) force_study = 0;    else if (strcmp(argv[op], "-s") == 0) force_study = 0;
1294    else if (strcmp(argv[op], "-s+") == 0)    else if (strcmp(argv[op], "-s+") == 0)
1295      {      {
1296      force_study = 1;      force_study = 1;
1297      force_study_options = PCRE_STUDY_JIT_COMPILE;      force_study_options = PCRE_STUDY_JIT_COMPILE;
1298      }      }
1299    else if (strcmp(argv[op], "-q") == 0) quiet = 1;    else if (strcmp(argv[op], "-q") == 0) quiet = 1;
1300    else if (strcmp(argv[op], "-b") == 0) debug = 1;    else if (strcmp(argv[op], "-b") == 0) debug = 1;
1301    else if (strcmp(argv[op], "-i") == 0) showinfo = 1;    else if (strcmp(argv[op], "-i") == 0) showinfo = 1;
# Line 1380  while (argc > 1 && argv[op][0] == '-') Line 1362  while (argc > 1 && argv[op][0] == '-')
1362      printf("  %sUnicode properties support\n", rc? "" : "No ");      printf("  %sUnicode properties support\n", rc? "" : "No ");
1363      (void)pcre_config(PCRE_CONFIG_JIT, &rc);      (void)pcre_config(PCRE_CONFIG_JIT, &rc);
1364      if (rc)      if (rc)
1365        printf("  Just-in-time compiler support%s\n", check_jit_arch()?        printf("  Just-in-time compiler support\n");
         "" : " (but this architecture is unsupported)");  
1366      else      else
1367        printf("  No just-in-time compiler support\n");        printf("  No just-in-time compiler support\n");
1368      (void)pcre_config(PCRE_CONFIG_NEWLINE, &rc);      (void)pcre_config(PCRE_CONFIG_NEWLINE, &rc);
# Line 1518  while (!done) Line 1499  while (!done)
1499    if (*p == '<' && strchr((char *)(p+1), '<') == NULL)    if (*p == '<' && strchr((char *)(p+1), '<') == NULL)
1500      {      {
1501      unsigned long int magic, get_options;      unsigned long int magic, get_options;
1502      uschar sbuf[8];      pcre_uint8 sbuf[8];
1503      FILE *f;      FILE *f;
1504    
1505      p++;      p++;
# Line 1541  while (!done) Line 1522  while (!done)
1522        (sbuf[4] << 24) | (sbuf[5] << 16) | (sbuf[6] << 8) | sbuf[7];        (sbuf[4] << 24) | (sbuf[5] << 16) | (sbuf[6] << 8) | sbuf[7];
1523    
1524      re = (real_pcre *)new_malloc(true_size);      re = (real_pcre *)new_malloc(true_size);
1525      regex_gotten_store = gotten_store;      regex_gotten_store = first_gotten_store;
1526    
1527      if (fread(re, 1, true_size, f) != true_size) goto FAIL_READ;      if (fread(re, 1, true_size, f) != true_size) goto FAIL_READ;
1528    
# Line 1650  while (!done) Line 1631  while (!done)
1631    /* Look for options after final delimiter */    /* Look for options after final delimiter */
1632    
1633    options = 0;    options = 0;
1634      study_options = 0;
1635    log_store = showstore;  /* default from command line */    log_store = showstore;  /* default from command line */
1636    
1637    while (*pp != 0)    while (*pp != 0)
# Line 1686  while (!done) Line 1668  while (!done)
1668  #endif  #endif
1669    
1670        case 'S':        case 'S':
1671        if (do_study == 0)        if (do_study == 0)
1672          {          {
1673          do_study = 1;          do_study = 1;
1674          if (*pp == '+')          if (*pp == '+')
1675            {            {
1676            study_options |= PCRE_STUDY_JIT_COMPILE;            study_options |= PCRE_STUDY_JIT_COMPILE;
1677            pp++;            pp++;
1678            }            }
1679          }          }
1680        else        else
1681          {          {
1682          do_study = 0;          do_study = 0;
# Line 1754  while (!done) Line 1736  while (!done)
1736    
1737        case '<':        case '<':
1738          {          {
1739          if (strncmpic(pp, (uschar *)"JS>", 3) == 0)          if (strncmpic(pp, (pcre_uint8 *)"JS>", 3) == 0)
1740            {            {
1741            options |= PCRE_JAVASCRIPT_COMPAT;            options |= PCRE_JAVASCRIPT_COMPAT;
1742            pp += 3;            pp += 3;
# Line 1798  while (!done) Line 1780  while (!done)
1780      if ((options & PCRE_UCP) != 0) cflags |= REG_UCP;      if ((options & PCRE_UCP) != 0) cflags |= REG_UCP;
1781      if ((options & PCRE_UNGREEDY) != 0) cflags |= REG_UNGREEDY;      if ((options & PCRE_UNGREEDY) != 0) cflags |= REG_UNGREEDY;
1782    
1783        first_gotten_store = 0;
1784      rc = regcomp(&preg, (char *)p, cflags);      rc = regcomp(&preg, (char *)p, cflags);
1785    
1786      /* Compilation failed; go back for another re, skipping to blank line      /* Compilation failed; go back for another re, skipping to blank line
# Line 1835  while (!done) Line 1818  while (!done)
1818            (double)CLOCKS_PER_SEC);            (double)CLOCKS_PER_SEC);
1819        }        }
1820    
1821        first_gotten_store = 0;
1822      re = pcre_compile((char *)p, options, &error, &erroroffset, tables);      re = pcre_compile((char *)p, options, &error, &erroroffset, tables);
1823    
1824      /* Compilation failed; go back for another re, skipping to blank line      /* Compilation failed; go back for another re, skipping to blank line
# Line 1869  while (!done) Line 1853  while (!done)
1853      new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);      new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);
1854      if ((get_options & PCRE_UTF8) != 0) use_utf8 = 1;      if ((get_options & PCRE_UTF8) != 0) use_utf8 = 1;
1855    
1856      /* Print information if required. There are now two info-returning      /* Extract the size for possible writing before possibly flipping it,
1857      functions. The old one has a limited interface and returns only limited      and remember the store that was got. */
1858      data. Check that it agrees with the newer one. */  
1859        true_size = ((real_pcre *)re)->size;
1860        regex_gotten_store = first_gotten_store;
1861    
1862        /* Output code size information if requested */
1863    
1864      if (log_store)      if (log_store)
1865        fprintf(outfile, "Memory allocation (code space): %d\n",        fprintf(outfile, "Memory allocation (code space): %d\n",
1866          (int)(gotten_store -          (int)(first_gotten_store -
1867                sizeof(real_pcre) -                sizeof(real_pcre) -
1868                ((real_pcre *)re)->name_count * ((real_pcre *)re)->name_entry_size));                ((real_pcre *)re)->name_count * ((real_pcre *)re)->name_entry_size));
1869    
     /* Extract the size for possible writing before possibly flipping it,  
     and remember the store that was got. */  
   
     true_size = ((real_pcre *)re)->size;  
     regex_gotten_store = gotten_store;  
   
1870      /* 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
1871      help with the matching, unless the pattern has the SS option, which      help with the matching, unless the pattern has the SS option, which
1872      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
# Line 1909  while (!done) Line 1891  while (!done)
1891        if (error != NULL)        if (error != NULL)
1892          fprintf(outfile, "Failed to study: %s\n", error);          fprintf(outfile, "Failed to study: %s\n", error);
1893        else if (extra != NULL)        else if (extra != NULL)
1894            {
1895          true_study_size = ((pcre_study_data *)(extra->study_data))->size;          true_study_size = ((pcre_study_data *)(extra->study_data))->size;
1896            if (log_store)
1897              {
1898              size_t jitsize;
1899              new_info(re, extra, PCRE_INFO_JITSIZE, &jitsize);
1900              if (jitsize != 0)
1901                fprintf(outfile, "Memory allocation (JIT code): %d\n", jitsize);
1902              }
1903            }
1904        }        }
1905    
1906      /* If /K was present, we set up for handling MARK data. */      /* If /K was present, we set up for handling MARK data. */
# Line 1942  while (!done) Line 1933  while (!done)
1933          (pcre_uint16)byteflip(rre->top_bracket, sizeof(rre->top_bracket));          (pcre_uint16)byteflip(rre->top_bracket, sizeof(rre->top_bracket));
1934        rre->top_backref =        rre->top_backref =
1935          (pcre_uint16)byteflip(rre->top_backref, sizeof(rre->top_backref));          (pcre_uint16)byteflip(rre->top_backref, sizeof(rre->top_backref));
1936        rre->first_byte =        rre->first_char =
1937          (pcre_uint16)byteflip(rre->first_byte, sizeof(rre->first_byte));          (pcre_uint16)byteflip(rre->first_char, sizeof(rre->first_char));
1938        rre->req_byte =        rre->req_char =
1939          (pcre_uint16)byteflip(rre->req_byte, sizeof(rre->req_byte));          (pcre_uint16)byteflip(rre->req_char, sizeof(rre->req_char));
1940        rre->name_table_offset = (pcre_uint16)byteflip(rre->name_table_offset,        rre->name_table_offset = (pcre_uint16)byteflip(rre->name_table_offset,
1941          sizeof(rre->name_table_offset));          sizeof(rre->name_table_offset));
1942        rre->name_entry_size = (pcre_uint16)byteflip(rre->name_entry_size,        rre->name_entry_size = (pcre_uint16)byteflip(rre->name_entry_size,
# Line 1962  while (!done) Line 1953  while (!done)
1953          }          }
1954        }        }
1955    
1956      /* Extract information from the compiled data if required */      /* Extract information from the compiled data if required. There are now
1957        two info-returning functions. The old one has a limited interface and
1958        returns only limited data. Check that it agrees with the newer one. */
1959    
1960      SHOW_INFO:      SHOW_INFO:
1961    
# Line 1983  while (!done) Line 1976  while (!done)
1976        int count, backrefmax, first_char, need_char, okpartial, jchanged,        int count, backrefmax, first_char, need_char, okpartial, jchanged,
1977          hascrorlf;          hascrorlf;
1978        int nameentrysize, namecount;        int nameentrysize, namecount;
1979        const uschar *nametable;        const pcre_uchar *nametable;
1980    
1981        new_info(re, NULL, PCRE_INFO_SIZE, &size);        new_info(re, NULL, PCRE_INFO_SIZE, &size);
1982        new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count);        new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count);
# Line 2101  while (!done) Line 2094  while (!done)
2094          }          }
2095        else        else
2096          {          {
2097          int ch = first_char & 255;          const char *caseless =
2098          const char *caseless = ((first_char & REQ_CASELESS) == 0)?            ((((real_pcre *)re)->flags & PCRE_FCH_CASELESS) == 0)?
2099            "" : " (caseless)";            "" : " (caseless)";
2100          if (PRINTHEX(ch))  
2101            fprintf(outfile, "First char = \'%c\'%s\n", ch, caseless);          if (PRINTHEX(first_char))
2102              fprintf(outfile, "First char = \'%c\'%s\n", first_char, caseless);
2103          else          else
2104            fprintf(outfile, "First char = %d%s\n", ch, caseless);            fprintf(outfile, "First char = %d%s\n", first_char, caseless);
2105          }          }
2106    
2107        if (need_char < 0)        if (need_char < 0)
# Line 2116  while (!done) Line 2110  while (!done)
2110          }          }
2111        else        else
2112          {          {
2113          int ch = need_char & 255;          const char *caseless =
2114          const char *caseless = ((need_char & REQ_CASELESS) == 0)?            ((((real_pcre *)re)->flags & PCRE_RCH_CASELESS) == 0)?
2115            "" : " (caseless)";            "" : " (caseless)";
2116          if (PRINTHEX(ch))  
2117            fprintf(outfile, "Need char = \'%c\'%s\n", ch, caseless);          if (PRINTHEX(need_char))
2118              fprintf(outfile, "Need char = \'%c\'%s\n", need_char, caseless);
2119          else          else
2120            fprintf(outfile, "Need char = %d%s\n", ch, caseless);            fprintf(outfile, "Need char = %d%s\n", need_char, caseless);
2121          }          }
2122    
2123        /* 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
# Line 2139  while (!done) Line 2134  while (!done)
2134            fprintf(outfile, "Study returned NULL\n");            fprintf(outfile, "Study returned NULL\n");
2135          else          else
2136            {            {
2137            uschar *start_bits = NULL;            pcre_uint8 *start_bits = NULL;
2138            int minlength;            int minlength;
2139    
2140            new_info(re, extra, PCRE_INFO_MINLENGTH, &minlength);            new_info(re, extra, PCRE_INFO_MINLENGTH, &minlength);
# Line 2177  while (!done) Line 2172  while (!done)
2172              fprintf(outfile, "\n");              fprintf(outfile, "\n");
2173              }              }
2174            }            }
2175    
2176          /* Show this only if the JIT was set by /S, not by -s. */          /* Show this only if the JIT was set by /S, not by -s. */
2177    
2178          if ((study_options & PCRE_STUDY_JIT_COMPILE) != 0)          if ((study_options & PCRE_STUDY_JIT_COMPILE) != 0)
2179            {            {
2180            int jit;            int jit;
2181            new_info(re, extra, PCRE_INFO_JIT, &jit);            new_info(re, extra, PCRE_INFO_JIT, &jit);
2182            if (jit)            if (jit)
2183              fprintf(outfile, "JIT study was successful\n");              fprintf(outfile, "JIT study was successful\n");
2184            else            else
2185  #ifdef SUPPORT_JIT  #ifdef SUPPORT_JIT
2186              fprintf(outfile, "JIT study was not successful\n");              fprintf(outfile, "JIT study was not successful\n");
2187  #else  #else
2188              fprintf(outfile, "JIT support is not available in this version of PCRE\n");              fprintf(outfile, "JIT support is not available in this version of PCRE\n");
2189  #endif  #endif
2190            }            }
2191          }          }
2192        }        }
2193    
# Line 2209  while (!done) Line 2204  while (!done)
2204          }          }
2205        else        else
2206          {          {
2207          uschar sbuf[8];          pcre_uint8 sbuf[8];
2208          sbuf[0] = (uschar)((true_size >> 24) & 255);          sbuf[0] = (pcre_uint8)((true_size >> 24) & 255);
2209          sbuf[1] = (uschar)((true_size >> 16) & 255);          sbuf[1] = (pcre_uint8)((true_size >> 16) & 255);
2210          sbuf[2] = (uschar)((true_size >>  8) & 255);          sbuf[2] = (pcre_uint8)((true_size >>  8) & 255);
2211          sbuf[3] = (uschar)((true_size) & 255);          sbuf[3] = (pcre_uint8)((true_size) & 255);
2212    
2213          sbuf[4] = (uschar)((true_study_size >> 24) & 255);          sbuf[4] = (pcre_uint8)((true_study_size >> 24) & 255);
2214          sbuf[5] = (uschar)((true_study_size >> 16) & 255);          sbuf[5] = (pcre_uint8)((true_study_size >> 16) & 255);
2215          sbuf[6] = (uschar)((true_study_size >>  8) & 255);          sbuf[6] = (pcre_uint8)((true_study_size >>  8) & 255);
2216          sbuf[7] = (uschar)((true_study_size) & 255);          sbuf[7] = (pcre_uint8)((true_study_size) & 255);
2217    
2218          if (fwrite(sbuf, 1, 8, f) < 8 ||          if (fwrite(sbuf, 1, 8, f) < 8 ||
2219              fwrite(re, 1, true_size, f) < true_size)              fwrite(re, 1, true_size, f) < true_size)
# Line 2261  while (!done) Line 2256  while (!done)
2256    
2257    for (;;)    for (;;)
2258      {      {
2259      uschar *q;      pcre_uint8 *q;
2260      uschar *bptr;      pcre_uint8 *bptr;
2261      int *use_offsets = offsets;      int *use_offsets = offsets;
2262      int use_size_offsets = size_offsets;      int use_size_offsets = size_offsets;
2263      int callout_data = 0;      int callout_data = 0;
# Line 2367  while (!done) Line 2362  while (!done)
2362            {            {
2363            unsigned char *pt = p;            unsigned char *pt = p;
2364            c = 0;            c = 0;
2365            while (isxdigit(*(++pt)))  
2366              c = c * 16 + tolower(*pt) - ((isdigit(*pt))? '0' : 'W');            /* We used to have "while (isxdigit(*(++pt)))" here, but it fails
2367              when isxdigit() is a macro that refers to its argument more than
2368              once. This is banned by the C Standard, but apparently happens in at
2369              least one MacOS environment. */
2370    
2371              for (pt++; isxdigit(*pt); pt++)
2372                c = c * 16 + tolower(*pt) - ((isdigit(*pt))? '0' : 'a' - 10);
2373            if (*pt == '}')            if (*pt == '}')
2374              {              {
2375              unsigned char buff8[8];              unsigned char buff8[8];
# Line 2398  while (!done) Line 2399  while (!done)
2399          c = 0;          c = 0;
2400          while (i++ < 2 && isxdigit(*p))          while (i++ < 2 && isxdigit(*p))
2401            {            {
2402            c = c * 16 + tolower(*p) - ((isdigit(*p))? '0' : 'W');            c = c * 16 + tolower(*p) - ((isdigit(*p))? '0' : 'a' - 10);
2403            p++;            p++;
2404            }            }
2405          break;          break;
# Line 2433  while (!done) Line 2434  while (!done)
2434            }            }
2435          else if (isalnum(*p))          else if (isalnum(*p))
2436            {            {
2437            uschar *npp = copynamesptr;            pcre_uchar *npp = copynamesptr;
2438            while (isalnum(*p)) *npp++ = *p++;            while (isalnum(*p)) *npp++ = *p++;
2439            *npp++ = 0;            *npp++ = 0;
2440            *npp = 0;            *npp = 0;
# Line 2503  while (!done) Line 2504  while (!done)
2504            }            }
2505          else if (isalnum(*p))          else if (isalnum(*p))
2506            {            {
2507            uschar *npp = getnamesptr;            pcre_uchar *npp = getnamesptr;
2508            while (isalnum(*p)) *npp++ = *p++;            while (isalnum(*p)) *npp++ = *p++;
2509            *npp++ = 0;            *npp++ = 0;
2510            *npp = 0;            *npp = 0;
# Line 2513  while (!done) Line 2514  while (!done)
2514            getnamesptr = npp;            getnamesptr = npp;
2515            }            }
2516          continue;          continue;
2517    
2518          case 'J':          case 'J':
2519          while(isdigit(*p)) n = n * 10 + *p++ - '0';          while(isdigit(*p)) n = n * 10 + *p++ - '0';
2520          if (extra != NULL          if (extra != NULL
2521              && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0              && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0
2522              && extra->executable_jit != NULL)              && extra->executable_jit != NULL)
2523            {            {
2524            if (jit_stack != NULL) pcre_jit_stack_free(jit_stack);            if (jit_stack != NULL) pcre_jit_stack_free(jit_stack);
2525            jit_stack = pcre_jit_stack_alloc(1, n * 1024);            jit_stack = pcre_jit_stack_alloc(1, n * 1024);
2526            pcre_assign_jit_stack(extra, jit_callback, jit_stack);            pcre_assign_jit_stack(extra, jit_callback, jit_stack);
2527            }            }
2528          continue;          continue;
2529    
2530          case 'L':          case 'L':
# Line 2749  while (!done) Line 2750  while (!done)
2750            extra->flags = 0;            extra->flags = 0;
2751            }            }
2752          else extra->flags &= ~PCRE_EXTRA_EXECUTABLE_JIT;          else extra->flags &= ~PCRE_EXTRA_EXECUTABLE_JIT;
2753    
2754          (void)check_match_limit(re, extra, bptr, len, start_offset,          (void)check_match_limit(re, extra, bptr, len, start_offset,
2755            options|g_notempty, use_offsets, use_size_offsets,            options|g_notempty, use_offsets, use_size_offsets,
2756            PCRE_EXTRA_MATCH_LIMIT, &(extra->match_limit),            PCRE_EXTRA_MATCH_LIMIT, &(extra->match_limit),
# Line 3104  while (!done) Line 3105  while (!done)
3105      setlocale(LC_CTYPE, "C");      setlocale(LC_CTYPE, "C");
3106      locale_set = 0;      locale_set = 0;
3107      }      }
3108    if (jit_stack != NULL)    if (jit_stack != NULL)
3109      {      {
3110      pcre_jit_stack_free(jit_stack);      pcre_jit_stack_free(jit_stack);
3111      jit_stack = NULL;      jit_stack = NULL;
3112      }      }
3113    }    }
3114    
3115  if (infile == stdin) fprintf(outfile, "\n");  if (infile == stdin) fprintf(outfile, "\n");

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

  ViewVC Help
Powered by ViewVC 1.1.5