/[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 860 by zherczeg, Mon Jan 9 20:12:58 2012 UTC revision 977 by zherczeg, Sun Jun 17 06:20:52 2012 UTC
# Line 188  static struct regression_test_case regre Line 188  static struct regression_test_case regre
188          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "^-", "a--\xe2\x80\xa8--" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "^-", "a--\xe2\x80\xa8--" },
189          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "^-", "a--\xc2\x85--" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY, 0, "^-", "a--\xc2\x85--" },
190          { 0, 0, "ab$", "ab" },          { 0, 0, "ab$", "ab" },
191          { 0, 0 | F_NOMATCH, "ab$", "ab\r\n" },          { 0, 0 | F_NOMATCH, "ab$", "abab\n\n" },
192            { PCRE_DOLLAR_ENDONLY, 0 | F_NOMATCH, "ab$", "abab\r\n" },
193          { PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 0, "a$", "\r\raa\n\naa\r\naa" },          { PCRE_MULTILINE | PCRE_NEWLINE_CRLF, 0, "a$", "\r\raa\n\naa\r\naa" },
194          { PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "a$", "aaa" },          { PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0, "a$", "aaa" },
195          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF, 0, "#$", "#\xc2\x85###\r#" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF, 0, "#$", "#\xc2\x85###\r#" },
# Line 652  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            /* (*MARK) verb. */
667            { MUA, 0, "a(*MARK:aa)a", "ababaa" },
668            { MUA, 0 | F_NOMATCH, "a(*:aa)a", "abab" },
669            { MUA, 0, "a(*:aa)(b(*:bb)b|bc)", "abc" },
670            { MUA, 0 | F_NOMATCH, "a(*:1)x|b(*:2)y", "abc" },
671            { MUA, 0, "(?>a(*:aa))b|ac", "ac" },
672            { MUA, 0, "(?(DEFINE)(a(*:aa)))(?1)", "a" },
673            { MUA, 0 | F_NOMATCH, "(?(DEFINE)((a)(*:aa)))(?1)b", "aa" },
674            { MUA, 0, "(?(DEFINE)(a(*:aa)))a(?1)b|aac", "aac" },
675            { MUA, 0, "(a(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },
676            { MUA, 0, "(a(*:aa)){0}(?:b(?1)b)+", "babba" },
677            { MUA, 0 | F_NOMATCH, "(a(*:aa)){0}(?:b(?1)b)+", "ba" },
678            { MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },
679            { MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b)+", "babba" },
680            { MUA, 0 | F_NOMATCH, "(a\\K(*:aa)){0}(?:b(?1)b)+", "ba" },
681    
682            /* (*COMMIT) verb. */
683            { MUA, 0 | F_NOMATCH, "a(*COMMIT)b", "ac" },
684            { MUA, 0, "aa(*COMMIT)b", "xaxaab" },
685            { MUA, 0 | F_NOMATCH, "a(*COMMIT)(*:msg)b|ac", "ac" },
686            { MUA, 0, "(?=a(*COMMIT)b|ac)ac|(*:m)(a)c", "ac" },
687            { MUA, 0, "(?!a(*COMMIT)(*:msg)b)a(c)|cd", "acd" },
688    
689          /* Deep recursion. */          /* Deep recursion. */
690          { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },          { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },
691          { MUA, 0, "(?:((?:(?:(?:\\w*?)+)??|(?>\\w)?|\\w*+)*)+)+?\\s", "aa+ " },          { MUA, 0, "(?:((?:(?:(?:\\w*?)+)??|(?>\\w)?|\\w*+)*)+)+?\\s", "aa+ " },
692          { MUA, 0, "((a?)+)+b", "aaaaaaaaaaaaa b" },          { MUA, 0, "((a?)+)+b", "aaaaaaaaaaaa b" },
693    
694          /* Deep recursion: Stack limit reached. */          /* Deep recursion: Stack limit reached. */
695          { MA, 0 | F_NOMATCH, "a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaaaaaaaaa" },          { MA, 0 | F_NOMATCH, "a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaaaaaaaaa" },
# Line 674  static const unsigned char *tables(int m Line 708  static const unsigned char *tables(int m
708          static unsigned char *tables_copy;          static unsigned char *tables_copy;
709          const char *errorptr;          const char *errorptr;
710          int erroroffset;          int erroroffset;
711          const unsigned char *default_tables;          unsigned char *default_tables;
712  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
713          pcre *regex;          pcre *regex;
714          char null_str[1] = { 0 };          char null_str[1] = { 0 };
# Line 721  static const unsigned char *tables(int m Line 755  static const unsigned char *tables(int m
755          return tables_copy;          return tables_copy;
756  }  }
757    
758    #ifdef SUPPORT_PCRE8
759  static pcre_jit_stack* callback8(void *arg)  static pcre_jit_stack* callback8(void *arg)
760  {  {
761          return (pcre_jit_stack *)arg;          return (pcre_jit_stack *)arg;
762  }  }
763    #endif
764    
765    #ifdef SUPPORT_PCRE16
766  static pcre16_jit_stack* callback16(void *arg)  static pcre16_jit_stack* callback16(void *arg)
767  {  {
768          return (pcre16_jit_stack *)arg;          return (pcre16_jit_stack *)arg;
769  }  }
770    #endif
771    
772  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
773  static void setstack8(pcre_extra *extra)  static void setstack8(pcre_extra *extra)
# Line 856  static int regression_tests(void) Line 894  static int regression_tests(void)
894  {  {
895          struct regression_test_case *current = regression_test_cases;          struct regression_test_case *current = regression_test_cases;
896          const char *error;          const char *error;
897            char *cpu_info;
898          int i, err_offs;          int i, err_offs;
899          int is_successful, is_ascii_pattern, is_ascii_input;          int is_successful, is_ascii_pattern, is_ascii_input;
900          int total = 0;          int total = 0;
901          int successful = 0;          int successful = 0;
902            int successful_row = 0;
903          int counter = 0;          int counter = 0;
904            int study_mode;
905  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
906          pcre *re8;          pcre *re8;
907          pcre_extra *extra8;          pcre_extra *extra8;
908            pcre_extra dummy_extra8;
909          int ovector8_1[32];          int ovector8_1[32];
910          int ovector8_2[32];          int ovector8_2[32];
911          int return_value8_1, return_value8_2;          int return_value8_1, return_value8_2;
912            unsigned char *mark8_1, *mark8_2;
913          int utf8 = 0, ucp8 = 0;          int utf8 = 0, ucp8 = 0;
914          int disabled_flags8 = 0;          int disabled_flags8 = 0;
915  #endif  #endif
916  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
917          pcre16 *re16;          pcre16 *re16;
918          pcre16_extra *extra16;          pcre16_extra *extra16;
919            pcre16_extra dummy_extra16;
920          int ovector16_1[32];          int ovector16_1[32];
921          int ovector16_2[32];          int ovector16_2[32];
922          int return_value16_1, return_value16_2;          int return_value16_1, return_value16_2;
923            PCRE_UCHAR16 *mark16_1, *mark16_2;
924          int utf16 = 0, ucp16 = 0;          int utf16 = 0, ucp16 = 0;
925          int disabled_flags16 = 0;          int disabled_flags16 = 0;
926          int length16;          int length16;
# Line 885  static int regression_tests(void) Line 930  static int regression_tests(void)
930          utf or ucp may make tests fail, if the pcre_exec result is the SAME, it is          utf or ucp may make tests fail, if the pcre_exec result is the SAME, it is
931          still considered successful from pcre_jit_test point of view. */          still considered successful from pcre_jit_test point of view. */
932    
933          printf("Running JIT regression\n");  #ifdef SUPPORT_PCRE8
934            pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);
935    #else
936            pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);
937    #endif
938    
939            printf("Running JIT regression tests\n");
940            printf("  target CPU of SLJIT compiler: %s\n", cpu_info);
941    
942  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
943          pcre_config(PCRE_CONFIG_UTF8, &utf8);          pcre_config(PCRE_CONFIG_UTF8, &utf8);
# Line 894  static int regression_tests(void) Line 946  static int regression_tests(void)
946                  disabled_flags8 |= PCRE_UTF8;                  disabled_flags8 |= PCRE_UTF8;
947          if (!ucp8)          if (!ucp8)
948                  disabled_flags8 |= PCRE_UCP;                  disabled_flags8 |= PCRE_UCP;
949          printf(" in  8 bit mode with utf8  %s and ucp %s:\n", utf8 ? "enabled" : "disabled", ucp8 ? "enabled" : "disabled");          printf("  in  8 bit mode with utf8  %s and ucp %s:\n", utf8 ? "enabled" : "disabled", ucp8 ? "enabled" : "disabled");
950  #endif  #endif
951  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
952          pcre16_config(PCRE_CONFIG_UTF16, &utf16);          pcre16_config(PCRE_CONFIG_UTF16, &utf16);
# Line 903  static int regression_tests(void) Line 955  static int regression_tests(void)
955                  disabled_flags16 |= PCRE_UTF8;                  disabled_flags16 |= PCRE_UTF8;
956          if (!ucp16)          if (!ucp16)
957                  disabled_flags16 |= PCRE_UCP;                  disabled_flags16 |= PCRE_UCP;
958          printf(" in 16 bit mode with utf16 %s and ucp %s:\n", utf16 ? "enabled" : "disabled", ucp16 ? "enabled" : "disabled");          printf("  in 16 bit mode with utf16 %s and ucp %s:\n", utf16 ? "enabled" : "disabled", ucp16 ? "enabled" : "disabled");
959  #endif  #endif
960    
961          while (current->pattern) {          while (current->pattern) {
# Line 917  static int regression_tests(void) Line 969  static int regression_tests(void)
969                          is_ascii_input = check_ascii(current->input);                          is_ascii_input = check_ascii(current->input);
970                  }                  }
971    
972                    if (current->flags & PCRE_PARTIAL_SOFT)
973                            study_mode = PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE;
974                    else if (current->flags & PCRE_PARTIAL_HARD)
975                            study_mode = PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE;
976                    else
977                            study_mode = PCRE_STUDY_JIT_COMPILE;
978                  error = NULL;                  error = NULL;
979  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
980                  re8 = NULL;                  re8 = NULL;
981                  if (!(current->start_offset & F_NO8))                  if (!(current->start_offset & F_NO8))
982                          re8 = pcre_compile(current->pattern,                          re8 = pcre_compile(current->pattern,
983                                  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),
984                                  &error, &err_offs, tables(0));                                  &error, &err_offs, tables(0));
985    
986                  extra8 = NULL;                  extra8 = NULL;
987                  if (re8) {                  if (re8) {
988                          error = NULL;                          error = NULL;
989                          extra8 = pcre_study(re8, PCRE_STUDY_JIT_COMPILE, &error);                          extra8 = pcre_study(re8, study_mode, &error);
990                          if (!extra8) {                          if (!extra8) {
991                                  printf("\n8 bit: Cannot study pattern: %s\n", current->pattern);                                  printf("\n8 bit: Cannot study pattern: %s\n", current->pattern);
992                                  pcre_free(re8);                                  pcre_free(re8);
# Line 940  static int regression_tests(void) Line 998  static int regression_tests(void)
998                                  pcre_free(re8);                                  pcre_free(re8);
999                                  re8 = NULL;                                  re8 = NULL;
1000                          }                          }
1001                            extra8->flags |= PCRE_EXTRA_MARK;
1002                  } else if (((utf8 && ucp8) || is_ascii_pattern) && !(current->start_offset & F_NO8))                  } else if (((utf8 && ucp8) || is_ascii_pattern) && !(current->start_offset & F_NO8))
1003                          printf("\n8 bit: Cannot compile pattern: %s\n", current->pattern);                          printf("\n8 bit: Cannot compile pattern: %s\n", current->pattern);
1004  #endif  #endif
# Line 952  static int regression_tests(void) Line 1011  static int regression_tests(void)
1011                  re16 = NULL;                  re16 = NULL;
1012                  if (!(current->start_offset & F_NO16))                  if (!(current->start_offset & F_NO16))
1013                          re16 = pcre16_compile(regtest_buf,                          re16 = pcre16_compile(regtest_buf,
1014                                  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),
1015                                  &error, &err_offs, tables(0));                                  &error, &err_offs, tables(0));
1016    
1017                  extra16 = NULL;                  extra16 = NULL;
1018                  if (re16) {                  if (re16) {
1019                          error = NULL;                          error = NULL;
1020                          extra16 = pcre16_study(re16, PCRE_STUDY_JIT_COMPILE, &error);                          extra16 = pcre16_study(re16, study_mode, &error);
1021                          if (!extra16) {                          if (!extra16) {
1022                                  printf("\n16 bit: Cannot study pattern: %s\n", current->pattern);                                  printf("\n16 bit: Cannot study pattern: %s\n", current->pattern);
1023                                  pcre16_free(re16);                                  pcre16_free(re16);
# Line 970  static int regression_tests(void) Line 1029  static int regression_tests(void)
1029                                  pcre16_free(re16);                                  pcre16_free(re16);
1030                                  re16 = NULL;                                  re16 = NULL;
1031                          }                          }
1032                            extra16->flags |= PCRE_EXTRA_MARK;
1033                  } else if (((utf16 && ucp16) || is_ascii_pattern) && !(current->start_offset & F_NO16))                  } else if (((utf16 && ucp16) || is_ascii_pattern) && !(current->start_offset & F_NO16))
1034                          printf("\n16 bit: Cannot compile pattern: %s\n", current->pattern);                          printf("\n16 bit: Cannot compile pattern: %s\n", current->pattern);
1035  #endif  #endif
# Line 992  static int regression_tests(void) Line 1052  static int regression_tests(void)
1052                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
1053                          ovector8_2[i] = -2;                          ovector8_2[i] = -2;
1054                  if (re8) {                  if (re8) {
1055                            mark8_1 = NULL;
1056                            mark8_2 = NULL;
1057                          setstack8(extra8);                          setstack8(extra8);
1058                            extra8->mark = &mark8_1;
1059                          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,
1060                                  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);
1061                          return_value8_2 = pcre_exec(re8, NULL, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,                          memset(&dummy_extra8, 0, sizeof(pcre_extra));
1062                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector8_2, 32);                          dummy_extra8.flags = PCRE_EXTRA_MARK;
1063                            dummy_extra8.mark = &mark8_2;
1064                            return_value8_2 = pcre_exec(re8, &dummy_extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1065                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_2, 32);
1066                  }                  }
1067  #endif  #endif
1068    
# Line 1008  static int regression_tests(void) Line 1074  static int regression_tests(void)
1074                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
1075                          ovector16_2[i] = -2;                          ovector16_2[i] = -2;
1076                  if (re16) {                  if (re16) {
1077                            mark16_1 = NULL;
1078                            mark16_2 = NULL;
1079                          setstack16(extra16);                          setstack16(extra16);
1080                          if ((current->flags & PCRE_UTF8) || (current->start_offset & F_FORCECONV))                          if ((current->flags & PCRE_UTF8) || (current->start_offset & F_FORCECONV))
1081                                  length16 = convert_utf8_to_utf16(current->input, regtest_buf, regtest_offsetmap, REGTEST_MAX_LENGTH);                                  length16 = convert_utf8_to_utf16(current->input, regtest_buf, regtest_offsetmap, REGTEST_MAX_LENGTH);
1082                          else                          else
1083                                  length16 = copy_char8_to_char16(current->input, regtest_buf, REGTEST_MAX_LENGTH);                                  length16 = copy_char8_to_char16(current->input, regtest_buf, REGTEST_MAX_LENGTH);
1084                            extra16->mark = &mark16_1;
1085                          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,
1086                                  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);
1087                          return_value16_2 = pcre16_exec(re16, NULL, regtest_buf, length16, current->start_offset & OFFSET_MASK,                          memset(&dummy_extra16, 0, sizeof(pcre16_extra));
1088                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector16_2, 32);                          dummy_extra16.flags = PCRE_EXTRA_MARK;
1089                            dummy_extra16.mark = &mark16_2;
1090                            return_value16_2 = pcre16_exec(re16, &dummy_extra16, regtest_buf, length16, current->start_offset & OFFSET_MASK,
1091                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_2, 32);
1092                  }                  }
1093  #endif  #endif
1094    
1095                    /* 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" : ""); */
1096    
1097                  /* 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.
1098                  Segfaults can still be captured. */                  Segfaults can still be captured. */
1099    
# Line 1033  static int regression_tests(void) Line 1107  static int regression_tests(void)
1107                                                  return_value8_1, return_value8_2, return_value16_1, return_value16_2,                                                  return_value8_1, return_value8_2, return_value16_1, return_value16_2,
1108                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1109                                          is_successful = 0;                                          is_successful = 0;
1110                                  } else if (return_value8_1 >= 0) {                                  } else if (return_value8_1 >= 0 || return_value8_1 == PCRE_ERROR_PARTIAL) {
1111                                          return_value8_1 *= 2;                                          if (return_value8_1 == PCRE_ERROR_PARTIAL) {
1112                                                    return_value8_1 = 2;
1113                                                    return_value16_1 = 2;
1114                                            } else {
1115                                                    return_value8_1 *= 2;
1116                                                    return_value16_1 *= 2;
1117                                            }
1118    
1119                                          /* Transform back the results. */                                          /* Transform back the results. */
1120                                          if (current->flags & PCRE_UTF8) {                                          if (current->flags & PCRE_UTF8) {
1121                                                  for (i = 0; i < return_value8_1; ++i) {                                                  for (i = 0; i < return_value8_1; ++i) {
# Line 1061  static int regression_tests(void) Line 1142  static int regression_tests(void)
1142                                          printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",                                          printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1143                                                  return_value8_1, return_value8_2, total, current->pattern, current->input);                                                  return_value8_1, return_value8_2, total, current->pattern, current->input);
1144                                          is_successful = 0;                                          is_successful = 0;
1145                                  } else if (return_value8_1 >= 0) {                                  } else if (return_value8_1 >= 0 || return_value8_1 == PCRE_ERROR_PARTIAL) {
1146                                          return_value8_1 *= 2;                                          if (return_value8_1 == PCRE_ERROR_PARTIAL)
1147                                                    return_value8_1 = 2;
1148                                            else
1149                                                    return_value8_1 *= 2;
1150    
1151                                          for (i = 0; i < return_value8_1; ++i)                                          for (i = 0; i < return_value8_1; ++i)
1152                                                  if (ovector8_1[i] != ovector8_2[i]) {                                                  if (ovector8_1[i] != ovector8_2[i]) {
1153                                                          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 1077  static int regression_tests(void) Line 1162  static int regression_tests(void)
1162                                          printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",                                          printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1163                                                  return_value16_1, return_value16_2, total, current->pattern, current->input);                                                  return_value16_1, return_value16_2, total, current->pattern, current->input);
1164                                          is_successful = 0;                                          is_successful = 0;
1165                                  } else if (return_value16_1 >= 0) {                                  } else if (return_value16_1 >= 0 || return_value16_1 == PCRE_ERROR_PARTIAL) {
1166                                          return_value16_1 *= 2;                                          if (return_value16_1 == PCRE_ERROR_PARTIAL)
1167                                                    return_value16_1 = 2;
1168                                            else
1169                                                    return_value16_1 *= 2;
1170    
1171                                          for (i = 0; i < return_value16_1; ++i)                                          for (i = 0; i < return_value16_1; ++i)
1172                                                  if (ovector16_1[i] != ovector16_2[i]) {                                                  if (ovector16_1[i] != ovector16_2[i]) {
1173                                                          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 1126  static int regression_tests(void) Line 1215  static int regression_tests(void)
1215  #endif  #endif
1216                  }                  }
1217    
1218                  if (is_successful)                  if (is_successful) {
1219                          successful++;  #ifdef SUPPORT_PCRE8
1220                            if (mark8_1 != mark8_2) {
1221                                    printf("8 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1222                                            total, current->pattern, current->input);
1223                                    is_successful = 0;
1224                            }
1225    #endif
1226    #ifdef SUPPORT_PCRE16
1227                            if (mark16_1 != mark16_2) {
1228                                    printf("16 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1229                                            total, current->pattern, current->input);
1230                                    is_successful = 0;
1231                            }
1232    #endif
1233                    }
1234    
1235  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1236                  if (re8) {                  if (re8) {
# Line 1142  static int regression_tests(void) Line 1245  static int regression_tests(void)
1245                  }                  }
1246  #endif  #endif
1247    
1248                  /* printf("[%d-%d|%d-%d]%s", ovector8_1[0], ovector8_1[1], ovector16_1[0], ovector16_1[1], (current->flags & PCRE_CASELESS) ? "C" : ""); */                  if (is_successful) {
1249                  printf(".");                          successful++;
1250                            successful_row++;
1251                            printf(".");
1252                            if (successful_row >= 60) {
1253                                    successful_row = 0;
1254                                    printf("\n");
1255                            }
1256                    } else
1257                            successful_row = 0;
1258    
1259                  fflush(stdout);                  fflush(stdout);
1260                  current++;                  current++;
1261          }          }

Legend:
Removed from v.860  
changed lines
  Added in v.977

  ViewVC Help
Powered by ViewVC 1.1.5