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

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

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

revision 785 by ph10, Mon Nov 21 10:41:54 2011 UTC revision 786 by zherczeg, Tue Dec 6 11:33:41 2011 UTC
# Line 51  POSSIBILITY OF SUCH DAMAGE. Line 51  POSSIBILITY OF SUCH DAMAGE.
51  #define PCRE_BUG 0x80000000  #define PCRE_BUG 0x80000000
52    
53  /*  /*
54   Hungarian utf8 characters   Letter characters:
55   \xc3\xa9 = 0xe9 = 233 (e') \xc3\x89 = 0xc9 = 201 (E')     \xe6\x92\xad = 0x64ad = 25773 (kanji)
56   \xc3\xa1 = 0xe1 = 225 (a') \xc3\x81 = 0xc1 = 193 (A')   Non-letter characters:
57   \xe6\x92\xad = 0x64ad = 25773 (a valid kanji)     \xc2\xa1 = 0xa1 =  (Inverted Exclamation Mark)
58   \xc2\x85 = 0x85 (NExt Line = NEL)     \xf3\xa9\xb7\x80 = 0xe9dc0 = 957888
59   \xc2\xa1 = 0xa1 (Inverted Exclamation Mark)   Newlines:
60   \xe2\x80\xa8 = 0x2028 (Line Separator)     \xc2\x85 = 0x85 = 133 (NExt Line = NEL)
61   \xc8\xba = 570 \xe2\xb1\xa5 = 11365 (lowercase length != uppercase length)     \xe2\x80\xa8 = 0x2028 = 8232 (Line Separator)
62   \xcc\x8d = 781 (Something with Mark property)   Othercase pairs:
63       \xc3\xa9 = 0xe9 = 233 (e')
64          \xc3\x89 = 0xc9 = 201 (E')
65       \xc3\xa1 = 0xe1 = 225 (a')
66          \xc3\x81 = 0xc1 = 193 (A')
67       \xc8\xba = 0x23a = 570
68          \xe2\xb1\xa5 = 0x2c65 = 11365
69       \xe1\xbd\xb8 = 0x1f78 = 8056
70          \xe1\xbf\xb8 = 0x1ff8 = 8184
71       \xf0\x90\x90\x80 = 0x10400 = 66560
72          \xf0\x90\x90\xa8 = 0x10428 = 66600
73     Mark property:
74       \xcc\x8d = 0x30d = 781
75     Special:
76       \xdf\xbf = 0x7ff = 2047 (highest 2 byte character)
77       \xe0\xa0\x80 = 0x800 = 2048 (lowest 2 byte character)
78       \xef\xbf\xbf = 0xffff = 65535 (highest 3 byte character)
79       \xf0\x90\x80\x80 = 0x10000 = 65536 (lowest 4 byte character)
80       \xf4\x8f\xbf\xbf = 0x10ffff = 1114111 (highest allowed utf character)
81  */  */
82    
 static void setstack(pcre_extra *extra);  
83  static int regression_tests(void);  static int regression_tests(void);
84    
85  int main(void)  int main(void)
# Line 76  int main(void) Line 93  int main(void)
93          return regression_tests();          return regression_tests();
94  }  }
95    
 static pcre_jit_stack* callback(void *arg)  
 {  
         return (pcre_jit_stack *)arg;  
 }  
   
 static void setstack(pcre_extra *extra)  
 {  
         static pcre_jit_stack *stack;  
         if (stack) pcre_jit_stack_free(stack);  
         stack = pcre_jit_stack_alloc(1, 1024 * 1024);  
         pcre_assign_jit_stack(extra, callback, stack);  
 }  
   
96  /* --------------------------------------------------------------------------------------- */  /* --------------------------------------------------------------------------------------- */
97    
98    #if !(defined SUPPORT_PCRE8) && !(defined SUPPORT_PCRE16)
99    #error SUPPORT_PCRE8 or SUPPORT_PCRE16 must be defined
100    #endif
101    
102  #define MUA     (PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)  #define MUA     (PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)
103  #define MUAP    (PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)  #define MUAP    (PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF | PCRE_UCP)
104  #define CMUA    (PCRE_CASELESS | PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)  #define CMUA    (PCRE_CASELESS | PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)
# Line 139  static struct regression_test_case regre Line 147  static struct regression_test_case regre
147          { CMA, 0, "\\Ca", "CDA" },          { CMA, 0, "\\Ca", "CDA" },
148          { MA, 0, "\\Cx", "cda" },          { MA, 0, "\\Cx", "cda" },
149          { CMA, 0, "\\Cx", "CDA" },          { CMA, 0, "\\Cx", "CDA" },
150            { CMUAP, 0, "\xf0\x90\x90\x80\xf0\x90\x90\xa8", "\xf0\x90\x90\xa8\xf0\x90\x90\x80" },
151            { CMUAP, 0, "\xf0\x90\x90\x80{2}", "\xf0\x90\x90\x80#\xf0\x90\x90\xa8\xf0\x90\x90\x80" },
152            { CMUAP, 0, "\xf0\x90\x90\xa8{2}", "\xf0\x90\x90\x80#\xf0\x90\x90\xa8\xf0\x90\x90\x80" },
153            { CMUAP, 0, "\xe1\xbd\xb8\xe1\xbf\xb8", "\xe1\xbf\xb8\xe1\xbd\xb8" },
154    
155          /* Assertions. */          /* Assertions. */
156          { MUA, 0, "\\b[^A]", "A_B#" },          { MUA, 0, "\\b[^A]", "A_B#" },
# Line 151  static struct regression_test_case regre Line 163  static struct regression_test_case regre
163          { MUAP, 0, "\\b[^A]\\B[^c]\\b[^_]\\B", "_\xc3\xa1\xe2\x80\xa8" },          { MUAP, 0, "\\b[^A]\\B[^c]\\b[^_]\\B", "_\xc3\xa1\xe2\x80\xa8" },
164          { MUAP, 0, "\\b\\w+\\B", "\xc3\x89\xc2\xa1\xe6\x92\xad\xc3\x81\xc3\xa1" },          { MUAP, 0, "\\b\\w+\\B", "\xc3\x89\xc2\xa1\xe6\x92\xad\xc3\x81\xc3\xa1" },
165          { MUA, 0, "\\b.", "\xcd\xbe" },          { MUA, 0, "\\b.", "\xcd\xbe" },
166            { CMUAP, 0, "\\By", "\xf0\x90\x90\xa8y" },
167          { MA, 0, "\\R^", "\n" },          { MA, 0, "\\R^", "\n" },
168          { MA, 1, "^", "\n" },          { MA, 1, "^", "\n" },
169          { 0, 0, "^ab", "ab" },          { 0, 0, "^ab", "ab" },
# Line 267  static struct regression_test_case regre Line 280  static struct regression_test_case regre
280          { MUA, 0, "\\b\\w+\\B", "x,a_cd" },          { MUA, 0, "\\b\\w+\\B", "x,a_cd" },
281          { MUAP, 0, "\\b[^\xc2\xa1]+\\B", "\xc3\x89\xc2\xa1\xe6\x92\xad\xc3\x81\xc3\xa1" },          { MUAP, 0, "\\b[^\xc2\xa1]+\\B", "\xc3\x89\xc2\xa1\xe6\x92\xad\xc3\x81\xc3\xa1" },
282          { CMUA, 0, "[^b]+(a*)([^c]?d{3})", "aaaaddd" },          { CMUA, 0, "[^b]+(a*)([^c]?d{3})", "aaaaddd" },
283            { CMUAP, 0, "\xe1\xbd\xb8{2}", "\xe1\xbf\xb8#\xe1\xbf\xb8\xe1\xbd\xb8" },
284    
285          /* Basic character sets. */          /* Basic character sets. */
286          { MUA, 0, "(?:\\s)+(?:\\S)+", "ab \t\xc3\xa9\xe6\x92\xad " },          { MUA, 0, "(?:\\s)+(?:\\S)+", "ab \t\xc3\xa9\xe6\x92\xad " },
# Line 449  static struct regression_test_case regre Line 463  static struct regression_test_case regre
463          { MUAP, 0, "(\\P{N})\\1{1,2}ww", "wwww" },          { MUAP, 0, "(\\P{N})\\1{1,2}ww", "wwww" },
464          { MUAP, 0, "(\\P{N})\\1{1,2}ww", "wwwww" },          { MUAP, 0, "(\\P{N})\\1{1,2}ww", "wwwww" },
465          { PCRE_UCP, 0, "(\\P{N})\\1{2,}", ".www." },          { PCRE_UCP, 0, "(\\P{N})\\1{2,}", ".www." },
466            { CMUAP, 0, "(\xf0\x90\x90\x80)\\1", "\xf0\x90\x90\xa8\xf0\x90\x90\xa8" },
467    
468          /* Assertions. */          /* Assertions. */
469          { MUA, 0, "(?=xx|yy|zz)\\w{4}", "abczzdefg" },          { MUA, 0, "(?=xx|yy|zz)\\w{4}", "abczzdefg" },
# Line 601  static struct regression_test_case regre Line 616  static struct regression_test_case regre
616          { 0, 0, NULL, NULL }          { 0, 0, NULL, NULL }
617  };  };
618    
619    pcre_jit_stack* callback(void *arg)
620    {
621            return (pcre_jit_stack *)arg;
622    }
623    
624    static void setstack(pcre_extra *extra, int realloc)
625    {
626            static pcre_jit_stack *stack;
627    
628            if (realloc) {
629                    if (stack)
630                            pcre_jit_stack_free(stack);
631                    stack = pcre_jit_stack_alloc(1, 1024 * 1024);
632            }
633            /* Extra can be NULL. */
634            pcre_assign_jit_stack(extra, callback, stack);
635    }
636    
637    #ifdef SUPPORT_PCRE16
638    
639    static int convert_utf8_to_utf16(const char *input, PCRE_SCHAR16 *output, int *offsetmap, int max_length)
640    {
641            unsigned char *ptr = (unsigned char*)input;
642            PCRE_SCHAR16 *optr = output;
643            unsigned int c;
644    
645            if (max_length == 0)
646                    return 0;
647    
648            while (*ptr && max_length > 1) {
649                    c = 0;
650                    if (offsetmap)
651                            *offsetmap++ = (int)(ptr - (unsigned char*)input);
652    
653                    if (!(*ptr & 0x80))
654                            c = *ptr++;
655                    else if (!(*ptr & 0x20)) {
656                            c = ((ptr[0] & 0x1f) << 6) | (ptr[1] & 0x3f);
657                            ptr += 2;
658                    } else if (!(*ptr & 0x10)) {
659                            c = ((ptr[0] & 0x0f) << 12) | ((ptr[1] & 0x3f) << 6) | (ptr[2] & 0x3f);
660                            ptr += 3;
661                    } else if (!(*ptr & 0x08)) {
662                            c = ((ptr[0] & 0x07) << 18) | ((ptr[1] & 0x3f) << 12) | ((ptr[2] & 0x3f) << 6) | (ptr[3] & 0x3f);
663                            ptr += 4;
664                    }
665    
666                    if (c < 65536) {
667                            *optr++ = c;
668                            max_length--;
669                    } else if (max_length <= 2) {
670                            *optr = '\0';
671                            return optr - output;
672                    } else {
673                            c -= 0x10000;
674                            *optr++ = 0xd800 | ((c >> 10) & 0x3ff);
675                            *optr++ = 0xdc00 | (c & 0x3ff);
676                            max_length -= 2;
677                            if (offsetmap)
678                                    offsetmap++;
679                    }
680            }
681            if (offsetmap)
682                    *offsetmap = (int)(ptr - (unsigned char*)input);
683            *optr = '\0';
684            return optr - output;
685    }
686    
687    static int copy_char8_to_char16(const char *input, PCRE_SCHAR16 *output, int max_length)
688    {
689            PCRE_SCHAR16 *optr = output;
690    
691            if (max_length == 0)
692                    return 0;
693    
694            while (*input && max_length > 1) {
695                    *optr++ = *input++;
696                    max_length--;
697            }
698            *optr = '\0';
699            return optr - output;
700    }
701    
702    #define REGTEST_MAX_LENGTH 4096
703    static PCRE_SCHAR16 regtest_buf[REGTEST_MAX_LENGTH];
704    static int regtest_offsetmap[REGTEST_MAX_LENGTH];
705    
706    #endif /* SUPPORT_PCRE16 */
707    
708  static int regression_tests(void)  static int regression_tests(void)
709  {  {
         pcre *re;  
710          struct regression_test_case *current = regression_test_cases;          struct regression_test_case *current = regression_test_cases;
711          const char *error;          const char *error;
712          pcre_extra *extra;          int i, err_offs, is_succesful;
713          int utf8 = 0, ucp = 0;          int total = 0;
714          int ovector1[32];          int succesful = 0;
         int ovector2[32];  
         int return_value1, return_value2;  
         int i, err_offs;  
         int total = 0, succesful = 0;  
715          int counter = 0;          int counter = 0;
716          int disabled_flags = PCRE_BUG;  #ifdef SUPPORT_PCRE8
717            pcre *re8;
718            pcre_extra *extra8;
719            int ovector8_1[32];
720            int ovector8_2[32];
721            int return_value8_1, return_value8_2;
722            int utf8 = 0, ucp8 = 0;
723            int disabled_flags8 = PCRE_BUG;
724    #endif
725    #ifdef SUPPORT_PCRE16
726            pcre *re16;
727            pcre_extra *extra16;
728            int ovector16_1[32];
729            int ovector16_2[32];
730            int return_value16_1, return_value16_2;
731            int utf16 = 0, ucp16 = 0;
732            int disabled_flags16 = PCRE_BUG;
733            int length16;
734    #endif
735    
736          /* This test compares the behaviour of interpreter and JIT. Although disabling          /* This test compares the behaviour of interpreter and JIT. Although disabling
737          utf8 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
738          still considered successful from pcre_jit_test point of view. */          still considered successful from pcre_jit_test point of view. */
739    
740            printf("Running JIT regression\n");
741    
742    #ifdef SUPPORT_PCRE8
743          pcre_config(PCRE_CONFIG_UTF8, &utf8);          pcre_config(PCRE_CONFIG_UTF8, &utf8);
744          pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);          pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp8);
745          if (!utf8)          if (!utf8)
746                  disabled_flags |= PCRE_UTF8;                  disabled_flags8 |= PCRE_UTF8;
747          if (!ucp)          if (!ucp8)
748                  disabled_flags |= PCRE_UCP;                  disabled_flags8 |= PCRE_UCP;
749            printf(" in  8 bit mode with utf8  %s and ucp %s:\n", utf8 ? "enabled" : "disabled", ucp8 ? "enabled" : "disabled");
750    #endif
751    #ifdef SUPPORT_PCRE16
752            pcre16_config(PCRE_CONFIG_UTF16, &utf16);
753            pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp16);
754            if (!utf16)
755                    disabled_flags16 |= PCRE_UTF8;
756            if (!ucp16)
757                    disabled_flags16 |= PCRE_UCP;
758            printf(" in 16 bit mode with utf16 %s and ucp %s:\n", utf16 ? "enabled" : "disabled", ucp16 ? "enabled" : "disabled");
759    #endif
760    
         printf("Running JIT regression tests with utf8 %s and ucp %s:\n", utf8 ? "enabled" : "disabled", ucp ? "enabled" : "disabled");  
761          while (current->pattern) {          while (current->pattern) {
762                  /* printf("\nPattern: %s :\n", current->pattern); */                  /* printf("\nPattern: %s :\n", current->pattern); */
763                  total++;                  total++;
764    
765                  error = NULL;                  error = NULL;
766                  re = pcre_compile(current->pattern, current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | disabled_flags), &error, &err_offs, NULL);  #ifdef SUPPORT_PCRE8
767                    re8 = pcre_compile(current->pattern,
768                  if (!re) {                          current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | disabled_flags8),
769                          if (utf8 && ucp)                          &error, &err_offs, NULL);
770                                  printf("\nCannot compile pattern: %s\n", current->pattern);  
771                          else {                  if (re8) {
772                                  /* Some patterns cannot be compiled when either of utf8                          error = NULL;
773                                  or ucp is disabled. We just skip them. */                          extra8 = pcre_study(re8, PCRE_STUDY_JIT_COMPILE, &error);
774                                  printf(".");                          if (!extra8) {
775                                  succesful++;                                  printf("\n8 bit: Cannot study pattern: %s\n", current->pattern);
776                                    pcre_free(re8);
777                                    re8 = NULL;
778                          }                          }
779                          current++;                          if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
780                          continue;                                  printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);
781                  }                                  pcre_free_study(extra8);
782                                    pcre_free(re8);
783                  error = NULL;                                  re8 = NULL;
784                  extra = pcre_study(re, PCRE_STUDY_JIT_COMPILE, &error);                          }
785                  if (!extra) {                  } else if (utf8 && ucp8)
786                          printf("\nCannot study pattern: %s\n", current->pattern);                          printf("\n8 bit: Cannot compile pattern: %s\n", current->pattern);
787                          current++;  #endif
788                          continue;  #ifdef SUPPORT_PCRE16
789                  }                  convert_utf8_to_utf16(current->pattern, regtest_buf, NULL, REGTEST_MAX_LENGTH);
790                    re16 = pcre16_compile(regtest_buf,
791                  if (!(extra->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {                          current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | disabled_flags16),
792                          printf("\nJIT compiler does not support: %s\n", current->pattern);                          &error, &err_offs, NULL);
793                          current++;                  if (re16) {
794                          continue;                          error = NULL;
795                  }                          extra16 = pcre16_study(re16, PCRE_STUDY_JIT_COMPILE, &error);
796                            if (!extra16) {
797                                    printf("\n16 bit: Cannot study pattern: %s\n", current->pattern);
798                                    pcre_free(re16);
799                                    re16 = NULL;
800                            }
801                            if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
802                                    printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);
803                                    pcre_free_study(extra16);
804                                    pcre_free(re16);
805                                    re16 = NULL;
806                            }
807                    } else if (utf16 && ucp16)
808                            printf("\n16 bit: Cannot compile pattern: %s\n", current->pattern);
809    #endif
810    
811                  counter++;                  counter++;
812                  if ((counter & 0x3) != 0)                  if ((counter & 0x3) != 0)
813                          setstack(extra);                          setstack(NULL, 1);
814    
815    #ifdef SUPPORT_PCRE8
816                    if (re8) {
817                            setstack(extra8, 0);
818                            for (i = 0; i < 32; ++i)
819                                    ovector8_1[i] = -2;
820                            return_value8_1 = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset,
821                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector8_1, 32);
822    
823                            for (i = 0; i < 32; ++i)
824                                    ovector8_2[i] = -2;
825                            return_value8_2 = pcre_exec(re8, NULL, current->input, strlen(current->input), current->start_offset,
826                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector8_2, 32);
827                    }
828    #endif
829    
830                  for (i = 0; i < 32; ++i)  #ifdef SUPPORT_PCRE16
831                          ovector1[i] = -2;                  if (re16) {
832                  return_value1 = pcre_exec(re, extra, current->input, strlen(current->input), current->start_offset, current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector1, 32);                          setstack(extra16, 0);
833                            if (current->flags & PCRE_UTF8)
834                  for (i = 0; i < 32; ++i)                                  length16 = convert_utf8_to_utf16(current->input, regtest_buf, regtest_offsetmap, REGTEST_MAX_LENGTH);
835                          ovector2[i] = -2;                          else
836                  return_value2 = pcre_exec(re, NULL, current->input, strlen(current->input), current->start_offset, current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector2, 32);                                  length16 = copy_char8_to_char16(current->input, regtest_buf, REGTEST_MAX_LENGTH);
837    
838                            for (i = 0; i < 32; ++i)
839                                    ovector16_1[i] = -2;
840                            return_value16_1 = pcre16_exec(re16, extra16, regtest_buf, length16, current->start_offset,
841                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector16_1, 32);
842    
843                            for (i = 0; i < 32; ++i)
844                                    ovector16_2[i] = -2;
845                            return_value16_2 = pcre16_exec(re16, NULL, regtest_buf, length16, current->start_offset,
846                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector16_2, 32);
847                    }
848    #endif
849    
850                  /* If PCRE_BUG is set, just run the test, but do not compare the results.                  /* If PCRE_BUG is set, just run the test, but do not compare the results.
851                  Segfaults can still be captured. */                  Segfaults can still be captured. */
                 if (!(current->flags & PCRE_BUG)) {  
                         if (return_value1 != return_value2) {  
                                 printf("\nReturn value differs(%d:%d): '%s' @ '%s'\n", return_value1, return_value2, current->pattern, current->input);  
                                 current++;  
                                 continue;  
                         }  
852    
853                          if (return_value1 >= 0) {                  is_succesful = 1;
854                                  return_value1 *= 2;                  if (!(current->flags & PCRE_BUG)) {
855                                  err_offs = 0;  #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
856                                  for (i = 0; i < return_value1; ++i)                          if ((current->flags & PCRE_UTF8) && utf8 && utf16) {
857                                          if (ovector1[i] != ovector2[i]) {                                  /* All results must be the same. */
858                                                  printf("\nOvector[%d] value differs(%d:%d): '%s' @ '%s' \n", i, ovector1[i], ovector2[i], current->pattern, current->input);                                  if (return_value8_1 != return_value8_2 || return_value8_1 != return_value16_1 || return_value8_1 != return_value16_2) {
859                                                  err_offs = 1;                                          printf("\n8 and 16 bit: Return value differs(%d:%d:%d:%d): [%d] '%s' @ '%s'\n",
860                                                    return_value8_1, return_value8_2, return_value16_1, return_value16_2,
861                                                    total, current->pattern, current->input);
862                                            is_succesful = 0;
863                                    } else if (return_value8_1 >= 0) {
864                                            return_value8_1 *= 2;
865                                            /* Transform back the results. */
866                                            for (i = 0; i < return_value8_1; ++i) {
867                                                    if (ovector16_1[i] >= 0)
868                                                            ovector16_1[i] = regtest_offsetmap[ovector16_1[i]];
869                                                    if (ovector16_2[i] >= 0)
870                                                            ovector16_2[i] = regtest_offsetmap[ovector16_2[i]];
871                                          }                                          }
872                                  if (err_offs) {  
873                                          current++;                                          for (i = 0; i < return_value8_1; ++i)
874                                          continue;                                                  if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector16_1[i] || ovector8_1[i] != ovector16_2[i]) {
875                                                            printf("\n8 and 16 bit: Ovector[%d] value differs(%d:%d:%d:%d): [%d] '%s' @ '%s' \n",
876                                                                    i, ovector8_1[i], ovector8_2[i], ovector16_1[i], ovector16_2[i],
877                                                                    total, current->pattern, current->input);
878                                                            is_succesful = 0;
879                                                    }
880                                  }                                  }
881                            } else {
882    #endif /* SUPPORT_PCRE8 && SUPPORT_PCRE16 */
883                                    /* Only the 8 bit and 16 bit results must be equal. */
884    #ifdef SUPPORT_PCRE8
885                                    if (return_value8_1 != return_value8_2) {
886                                            printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
887                                                    return_value8_1, return_value8_2, total, current->pattern, current->input);
888                                            is_succesful = 0;
889                                    } else if (return_value8_1 >= 0) {
890                                            return_value8_1 *= 2;
891                                            for (i = 0; i < return_value8_1; ++i)
892                                                    if (ovector8_1[i] != ovector8_2[i]) {
893                                                            printf("\n8 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s' \n",
894                                                                    i, ovector8_1[i], ovector8_2[i], total, current->pattern, current->input);
895                                                            is_succesful = 0;
896                                                    }
897                                    }
898    #endif
899    
900    #ifdef SUPPORT_PCRE16
901                                    if (return_value16_1 != return_value16_2) {
902                                            printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
903                                                    return_value16_1, return_value16_2, total, current->pattern, current->input);
904                                            is_succesful = 0;
905                                    } else if (return_value16_1 >= 0) {
906                                            return_value16_1 *= 2;
907                                            for (i = 0; i < return_value16_1; ++i)
908                                                    if (ovector16_1[i] != ovector16_2[i]) {
909                                                            printf("\n16 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s' \n",
910                                                                    i, ovector16_1[i], ovector16_2[i], total, current->pattern, current->input);
911                                                            is_succesful = 0;
912                                                    }
913                                    }
914    #endif
915    
916    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
917                          }                          }
918    #endif /* SUPPORT_PCRE8 && SUPPORT_PCRE16 */
919                  }                  }
920    
921                  pcre_free_study(extra);                  if (is_succesful)
922                  pcre_free(re);                          succesful++;
923    
924    #ifdef SUPPORT_PCRE8
925                    if (re8) {
926                            pcre_free_study(extra8);
927                            pcre_free(re8);
928                    }
929    #endif
930    #ifdef SUPPORT_PCRE16
931                    if (re16) {
932                            pcre16_free_study(extra16);
933                            pcre_free(re16);
934                    }
935    #endif
936    
937                  /* printf("[%d-%d]%s", ovector1[0], ovector1[1], (current->flags & PCRE_CASELESS) ? "C" : ""); */                  /* printf("[%d-%d]%s", ovector1[0], ovector1[1], (current->flags & PCRE_CASELESS) ? "C" : ""); */
938                  printf(".");                  printf(".");
939                  fflush(stdout);                  fflush(stdout);
940                  current++;                  current++;
                 succesful++;  
941          }          }
942    
943          if (total == succesful) {          if (total == succesful) {
# Line 717  static int regression_tests(void) Line 949  static int regression_tests(void)
949          }          }
950  }  }
951    
952    
953  /* End of pcre_jit_test.c */  /* End of pcre_jit_test.c */

Legend:
Removed from v.785  
changed lines
  Added in v.786

  ViewVC Help
Powered by ViewVC 1.1.5