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

Diff of /code/trunk/pcre_jit_test.c

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

revision 911 by zherczeg, Fri Feb 10 08:05:30 2012 UTC revision 914 by zherczeg, Mon Feb 13 06:04:50 2012 UTC
# Line 653  static struct regression_test_case regre Line 653  static struct regression_test_case regre
653          { 0, 0 | F_NO8 | F_FORCECONV, "\\v+?\\V+?#", "\xe2\x80\xa9\xe2\x80\xa9\xef\xbf\xbf\xef\xbf\xbf#" },          { 0, 0 | F_NO8 | F_FORCECONV, "\\v+?\\V+?#", "\xe2\x80\xa9\xe2\x80\xa9\xef\xbf\xbf\xef\xbf\xbf#" },
654          { 0, 0 | F_NO8 | F_FORCECONV, "\\h+?\\H+?#", "\xe1\xa0\x8e\xe1\xa0\x8e\xef\xbf\xbf\xef\xbf\xbf#" },          { 0, 0 | F_NO8 | F_FORCECONV, "\\h+?\\H+?#", "\xe1\xa0\x8e\xe1\xa0\x8e\xef\xbf\xbf\xef\xbf\xbf#" },
655    
656            /* Partial matching. */
657            { MUA | PCRE_PARTIAL_SOFT, 0, "ab", "a" },
658            { MUA | PCRE_PARTIAL_SOFT, 0, "ab|a", "a" },
659            { MUA | PCRE_PARTIAL_HARD, 0, "ab|a", "a" },
660            { MUA | PCRE_PARTIAL_SOFT, 0, "\\b#", "a" },
661            { MUA | PCRE_PARTIAL_SOFT, 0, "(?<=a)b", "a" },
662            { MUA | PCRE_PARTIAL_SOFT, 0, "abc|(?<=xxa)bc", "xxab" },
663            { MUA | PCRE_PARTIAL_SOFT, 0, "a\\B", "a" },
664            { MUA | PCRE_PARTIAL_HARD, 0, "a\\b", "a" },
665    
666          /* Deep recursion. */          /* Deep recursion. */
667          { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },          { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },
668          { MUA, 0, "(?:((?:(?:(?:\\w*?)+)??|(?>\\w)?|\\w*+)*)+)+?\\s", "aa+ " },          { MUA, 0, "(?:((?:(?:(?:\\w*?)+)??|(?>\\w)?|\\w*+)*)+)+?\\s", "aa+ " },
# Line 867  static int regression_tests(void) Line 877  static int regression_tests(void)
877          int total = 0;          int total = 0;
878          int successful = 0;          int successful = 0;
879          int counter = 0;          int counter = 0;
880            int study_mode;
881  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
882          pcre *re8;          pcre *re8;
883          pcre_extra *extra8;          pcre_extra *extra8;
# Line 930  static int regression_tests(void) Line 941  static int regression_tests(void)
941                          is_ascii_input = check_ascii(current->input);                          is_ascii_input = check_ascii(current->input);
942                  }                  }
943    
944                    if (current->flags & PCRE_PARTIAL_SOFT)
945                            study_mode = PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE;
946                    else if (current->flags & PCRE_PARTIAL_HARD)
947                            study_mode = PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE;
948                    else
949                            study_mode = PCRE_STUDY_JIT_COMPILE;
950                  error = NULL;                  error = NULL;
951  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
952                  re8 = NULL;                  re8 = NULL;
953                  if (!(current->start_offset & F_NO8))                  if (!(current->start_offset & F_NO8))
954                          re8 = pcre_compile(current->pattern,                          re8 = pcre_compile(current->pattern,
955                                  current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | disabled_flags8),                                  current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags8),
956                                  &error, &err_offs, tables(0));                                  &error, &err_offs, tables(0));
957    
958                  extra8 = NULL;                  extra8 = NULL;
959                  if (re8) {                  if (re8) {
960                          error = NULL;                          error = NULL;
961                          extra8 = pcre_study(re8, PCRE_STUDY_JIT_COMPILE, &error);                          extra8 = pcre_study(re8, study_mode, &error);
962                          if (!extra8) {                          if (!extra8) {
963                                  printf("\n8 bit: Cannot study pattern: %s\n", current->pattern);                                  printf("\n8 bit: Cannot study pattern: %s\n", current->pattern);
964                                  pcre_free(re8);                                  pcre_free(re8);
# Line 965  static int regression_tests(void) Line 982  static int regression_tests(void)
982                  re16 = NULL;                  re16 = NULL;
983                  if (!(current->start_offset & F_NO16))                  if (!(current->start_offset & F_NO16))
984                          re16 = pcre16_compile(regtest_buf,                          re16 = pcre16_compile(regtest_buf,
985                                  current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | disabled_flags16),                                  current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags16),
986                                  &error, &err_offs, tables(0));                                  &error, &err_offs, tables(0));
987    
988                  extra16 = NULL;                  extra16 = NULL;
989                  if (re16) {                  if (re16) {
990                          error = NULL;                          error = NULL;
991                          extra16 = pcre16_study(re16, PCRE_STUDY_JIT_COMPILE, &error);                          extra16 = pcre16_study(re16, study_mode, &error);
992                          if (!extra16) {                          if (!extra16) {
993                                  printf("\n16 bit: Cannot study pattern: %s\n", current->pattern);                                  printf("\n16 bit: Cannot study pattern: %s\n", current->pattern);
994                                  pcre16_free(re16);                                  pcre16_free(re16);
# Line 1007  static int regression_tests(void) Line 1024  static int regression_tests(void)
1024                  if (re8) {                  if (re8) {
1025                          setstack8(extra8);                          setstack8(extra8);
1026                          return_value8_1 = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,                          return_value8_1 = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1027                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector8_1, 32);                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32);
1028                          return_value8_2 = pcre_exec(re8, NULL, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,                          return_value8_2 = pcre_exec(re8, NULL, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1029                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector8_2, 32);                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_2, 32);
1030                  }                  }
1031  #endif  #endif
1032    
# Line 1027  static int regression_tests(void) Line 1044  static int regression_tests(void)
1044                          else                          else
1045                                  length16 = copy_char8_to_char16(current->input, regtest_buf, REGTEST_MAX_LENGTH);                                  length16 = copy_char8_to_char16(current->input, regtest_buf, REGTEST_MAX_LENGTH);
1046                          return_value16_1 = pcre16_exec(re16, extra16, regtest_buf, length16, current->start_offset & OFFSET_MASK,                          return_value16_1 = pcre16_exec(re16, extra16, regtest_buf, length16, current->start_offset & OFFSET_MASK,
1047                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector16_1, 32);                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32);
1048                          return_value16_2 = pcre16_exec(re16, NULL, regtest_buf, length16, current->start_offset & OFFSET_MASK,                          return_value16_2 = pcre16_exec(re16, NULL, regtest_buf, length16, current->start_offset & OFFSET_MASK,
1049                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector16_2, 32);                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_2, 32);
1050                  }                  }
1051  #endif  #endif
1052    
1053                    /* printf("[%d-%d|%d-%d|%d-%d]%s", return_value8_1, return_value16_1, ovector8_1[0], ovector8_1[1], ovector16_1[0], ovector16_1[1], (current->flags & PCRE_CASELESS) ? "C" : ""); */
1054    
1055                  /* If F_DIFF is set, just run the test, but do not compare the results.                  /* If F_DIFF is set, just run the test, but do not compare the results.
1056                  Segfaults can still be captured. */                  Segfaults can still be captured. */
1057    
# Line 1046  static int regression_tests(void) Line 1065  static int regression_tests(void)
1065                                                  return_value8_1, return_value8_2, return_value16_1, return_value16_2,                                                  return_value8_1, return_value8_2, return_value16_1, return_value16_2,
1066                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1067                                          is_successful = 0;                                          is_successful = 0;
1068                                  } else if (return_value8_1 >= 0) {                                  } else if (return_value8_1 >= 0 || return_value8_1 == PCRE_ERROR_PARTIAL) {
1069                                          return_value8_1 *= 2;                                          if (return_value8_1 == PCRE_ERROR_PARTIAL) {
1070                                                    return_value8_1 = 2;
1071                                                    return_value16_1 = 2;
1072                                            } else {
1073                                                    return_value8_1 *= 2;
1074                                                    return_value16_1 *= 2;
1075                                            }
1076    
1077                                          /* Transform back the results. */                                          /* Transform back the results. */
1078                                          if (current->flags & PCRE_UTF8) {                                          if (current->flags & PCRE_UTF8) {
1079                                                  for (i = 0; i < return_value8_1; ++i) {                                                  for (i = 0; i < return_value8_1; ++i) {
# Line 1074  static int regression_tests(void) Line 1100  static int regression_tests(void)
1100                                          printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",                                          printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1101                                                  return_value8_1, return_value8_2, total, current->pattern, current->input);                                                  return_value8_1, return_value8_2, total, current->pattern, current->input);
1102                                          is_successful = 0;                                          is_successful = 0;
1103                                  } else if (return_value8_1 >= 0) {                                  } else if (return_value8_1 >= 0 || return_value8_1 == PCRE_ERROR_PARTIAL) {
1104                                          return_value8_1 *= 2;                                          if (return_value8_1 == PCRE_ERROR_PARTIAL)
1105                                                    return_value8_1 = 2;
1106                                            else
1107                                                    return_value8_1 *= 2;
1108    
1109                                          for (i = 0; i < return_value8_1; ++i)                                          for (i = 0; i < return_value8_1; ++i)
1110                                                  if (ovector8_1[i] != ovector8_2[i]) {                                                  if (ovector8_1[i] != ovector8_2[i]) {
1111                                                          printf("\n8 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",                                                          printf("\n8 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
# Line 1090  static int regression_tests(void) Line 1120  static int regression_tests(void)
1120                                          printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",                                          printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1121                                                  return_value16_1, return_value16_2, total, current->pattern, current->input);                                                  return_value16_1, return_value16_2, total, current->pattern, current->input);
1122                                          is_successful = 0;                                          is_successful = 0;
1123                                  } else if (return_value16_1 >= 0) {                                  } else if (return_value16_1 >= 0 || return_value16_1 == PCRE_ERROR_PARTIAL) {
1124                                          return_value16_1 *= 2;                                          if (return_value16_1 == PCRE_ERROR_PARTIAL)
1125                                                    return_value16_1 = 2;
1126                                            else
1127                                                    return_value16_1 *= 2;
1128    
1129                                          for (i = 0; i < return_value16_1; ++i)                                          for (i = 0; i < return_value16_1; ++i)
1130                                                  if (ovector16_1[i] != ovector16_2[i]) {                                                  if (ovector16_1[i] != ovector16_2[i]) {
1131                                                          printf("\n16 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",                                                          printf("\n16 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
# Line 1155  static int regression_tests(void) Line 1189  static int regression_tests(void)
1189                  }                  }
1190  #endif  #endif
1191    
                 /* printf("[%d-%d|%d-%d]%s", ovector8_1[0], ovector8_1[1], ovector16_1[0], ovector16_1[1], (current->flags & PCRE_CASELESS) ? "C" : ""); */  
1192                  printf(".");                  printf(".");
1193                  fflush(stdout);                  fflush(stdout);
1194                  current++;                  current++;

Legend:
Removed from v.911  
changed lines
  Added in v.914

  ViewVC Help
Powered by ViewVC 1.1.5