/[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 977 by zherczeg, Sun Jun 17 06:20:52 2012 UTC revision 1055 by chpe, Tue Oct 16 15:53:30 2012 UTC
# Line 48  POSSIBILITY OF SUCH DAMAGE. Line 48  POSSIBILITY OF SUCH DAMAGE.
48  #include <string.h>  #include <string.h>
49  #include "pcre.h"  #include "pcre.h"
50    
51    
52    #include "pcre_internal.h"
53    
54  #define PCRE_BUG 0x80000000  #define PCRE_BUG 0x80000000
55    
56  /*  /*
# Line 87  static int regression_tests(void); Line 90  static int regression_tests(void);
90  int main(void)  int main(void)
91  {  {
92          int jit = 0;          int jit = 0;
93  #ifdef SUPPORT_PCRE8  #if defined SUPPORT_PCRE8
94          pcre_config(PCRE_CONFIG_JIT, &jit);          pcre_config(PCRE_CONFIG_JIT, &jit);
95  #else  #elif defined SUPPORT_PCRE16
96          pcre16_config(PCRE_CONFIG_JIT, &jit);          pcre16_config(PCRE_CONFIG_JIT, &jit);
97    #elif defined SUPPORT_PCRE32
98            pcre32_config(PCRE_CONFIG_JIT, &jit);
99  #endif  #endif
100          if (!jit) {          if (!jit) {
101                  printf("JIT must be enabled to run pcre_jit_test\n");                  printf("JIT must be enabled to run pcre_jit_test\n");
# Line 101  int main(void) Line 106  int main(void)
106    
107  /* --------------------------------------------------------------------------------------- */  /* --------------------------------------------------------------------------------------- */
108    
109  #if !(defined SUPPORT_PCRE8) && !(defined SUPPORT_PCRE16)  #if !(defined SUPPORT_PCRE8) && !(defined SUPPORT_PCRE16) && !(defined SUPPORT_PCRE32)
110  #error SUPPORT_PCRE8 or SUPPORT_PCRE16 must be defined  #error SUPPORT_PCRE8 or SUPPORT_PCRE16 or SUPPORT_PCRE32 must be defined
111  #endif  #endif
112    
113  #define MUA     (PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)  #define MUA     (PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANYCRLF)
# Line 116  int main(void) Line 121  int main(void)
121  #define OFFSET_MASK     0x00ffff  #define OFFSET_MASK     0x00ffff
122  #define F_NO8           0x010000  #define F_NO8           0x010000
123  #define F_NO16          0x020000  #define F_NO16          0x020000
124    #define F_NO32          0x020000
125  #define F_NOMATCH       0x040000  #define F_NOMATCH       0x040000
126  #define F_DIFF          0x080000  #define F_DIFF          0x080000
127  #define F_FORCECONV     0x100000  #define F_FORCECONV     0x100000
# Line 412  static struct regression_test_case regre Line 418  static struct regression_test_case regre
418          { CMA, 0, "(?>((?>a{32}|b+|(a*))?(?>c+|d*)?\?)+e)+?f", "aaccebbdde bbdaaaccebbdee bbdaaaccebbdeef" },          { CMA, 0, "(?>((?>a{32}|b+|(a*))?(?>c+|d*)?\?)+e)+?f", "aaccebbdde bbdaaaccebbdee bbdaaaccebbdeef" },
419          { MUA, 0, "(?>(?:(?>aa|a||x)+?b|(?>aa|a||(x))+?c)?(?>[ad]{0,2})*?d)+d", "aaacdbaabdcabdbaaacd aacaabdbdcdcaaaadaabcbaadd" },          { MUA, 0, "(?>(?:(?>aa|a||x)+?b|(?>aa|a||(x))+?c)?(?>[ad]{0,2})*?d)+d", "aaacdbaabdcabdbaaacd aacaabdbdcdcaaaadaabcbaadd" },
420          { MUA, 0, "(?>(?:(?>aa|a||(x))+?b|(?>aa|a||x)+?c)?(?>[ad]{0,2})*?d)+d", "aaacdbaabdcabdbaaacd aacaabdbdcdcaaaadaabcbaadd" },          { MUA, 0, "(?>(?:(?>aa|a||(x))+?b|(?>aa|a||x)+?c)?(?>[ad]{0,2})*?d)+d", "aaacdbaabdcabdbaaacd aacaabdbdcdcaaaadaabcbaadd" },
421          { MUA, 0 | F_NOMATCH | F_PROPERTY, "\\X", "\xcc\x8d\xcc\x8d" },          { MUA, 0 | F_PROPERTY, "\\X", "\xcc\x8d\xcc\x8d" },
422          { MUA, 0 | F_PROPERTY, "\\X", "\xcc\x8d\xcc\x8d#\xcc\x8d\xcc\x8d" },          { MUA, 0 | F_PROPERTY, "\\X", "\xcc\x8d\xcc\x8d#\xcc\x8d\xcc\x8d" },
423          { MUA, 0 | F_PROPERTY, "\\X+..", "\xcc\x8d#\xcc\x8d#\xcc\x8d\xcc\x8d" },          { MUA, 0 | F_PROPERTY, "\\X+..", "\xcc\x8d#\xcc\x8d#\xcc\x8d\xcc\x8d" },
424          { MUA, 0 | F_PROPERTY, "\\X{2,4}", "abcdef" },          { MUA, 0 | F_PROPERTY, "\\X{2,4}", "abcdef" },
# Line 583  static struct regression_test_case regre Line 589  static struct regression_test_case regre
589          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "[abc]", "\na" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "[abc]", "\na" },
590          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^a", "\na" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^a", "\na" },
591          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^(?<=\n)", "\na" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^(?<=\n)", "\na" },
592            { MUA | PCRE_FIRSTLINE, 0, "\xf0\x90\x90\x80", "\xf0\x90\x90\x80" },
593          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\xc2\x85#" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\xc2\x85#" },
594          { PCRE_MULTILINE | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\x85#" },          { PCRE_MULTILINE | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\x85#" },
595          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^#", "\xe2\x80\xa8#" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^#", "\xe2\x80\xa8#" },
# Line 592  static struct regression_test_case regre Line 599  static struct regression_test_case regre
599          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_NOMATCH, "ba", "bbb\r\nba" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_NOMATCH, "ba", "bbb\r\nba" },
600          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_NOMATCH | F_PROPERTY, "\\p{Any}{4}|a", "\r\na" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_NOMATCH | F_PROPERTY, "\\p{Any}{4}|a", "\r\na" },
601          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 1, ".", "\r\n" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 1, ".", "\r\n" },
602            { PCRE_FIRSTLINE | PCRE_NEWLINE_LF | PCRE_DOTALL, 0 | F_NOMATCH, "ab.", "ab" },
603    
604          /* Recurse. */          /* Recurse. */
605          { MUA, 0, "(a)(?1)", "aa" },          { MUA, 0, "(a)(?1)", "aa" },
# Line 709  static const unsigned char *tables(int m Line 717  static const unsigned char *tables(int m
717          const char *errorptr;          const char *errorptr;
718          int erroroffset;          int erroroffset;
719          unsigned char *default_tables;          unsigned char *default_tables;
720  #ifdef SUPPORT_PCRE8  #if defined SUPPORT_PCRE8
721          pcre *regex;          pcre *regex;
722          char null_str[1] = { 0 };          char null_str[1] = { 0 };
723  #else  #elif defined SUPPORT_PCRE16
724          pcre16 *regex;          pcre16 *regex;
725          PCRE_UCHAR16 null_str[1] = { 0 };          PCRE_UCHAR16 null_str[1] = { 0 };
726    #elif defined SUPPORT_PCRE32
727            pcre32 *regex;
728            PCRE_UCHAR32 null_str[1] = { 0 };
729  #endif  #endif
730    
731          if (mode) {          if (mode) {
# Line 728  static const unsigned char *tables(int m Line 739  static const unsigned char *tables(int m
739                  return tables_copy;                  return tables_copy;
740    
741          default_tables = NULL;          default_tables = NULL;
742  #ifdef SUPPORT_PCRE8  #if defined SUPPORT_PCRE8
743          regex = pcre_compile(null_str, 0, &errorptr, &erroroffset, NULL);          regex = pcre_compile(null_str, 0, &errorptr, &erroroffset, NULL);
744          if (regex) {          if (regex) {
745                  pcre_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);                  pcre_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
746                  pcre_free(regex);                  pcre_free(regex);
747          }          }
748  #else  #elif defined SUPPORT_PCRE16
749          regex = pcre16_compile(null_str, 0, &errorptr, &erroroffset, NULL);          regex = pcre16_compile(null_str, 0, &errorptr, &erroroffset, NULL);
750          if (regex) {          if (regex) {
751                  pcre16_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);                  pcre16_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
752                  pcre16_free(regex);                  pcre16_free(regex);
753          }          }
754    #elif defined SUPPORT_PCRE32
755            regex = pcre32_compile(null_str, 0, &errorptr, &erroroffset, NULL);
756            if (regex) {
757                    pcre32_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
758                    pcre32_free(regex);
759            }
760  #endif  #endif
761          /* Shouldn't ever happen. */          /* Shouldn't ever happen. */
762          if (!default_tables)          if (!default_tables)
# Line 769  static pcre16_jit_stack* callback16(void Line 786  static pcre16_jit_stack* callback16(void
786  }  }
787  #endif  #endif
788    
789    #ifdef SUPPORT_PCRE32
790    static pcre32_jit_stack* callback32(void *arg)
791    {
792            return (pcre32_jit_stack *)arg;
793    }
794    #endif
795    
796  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
797  static void setstack8(pcre_extra *extra)  static void setstack8(pcre_extra *extra)
798  {  {
# Line 807  static void setstack16(pcre16_extra *ext Line 831  static void setstack16(pcre16_extra *ext
831  }  }
832  #endif /* SUPPORT_PCRE8 */  #endif /* SUPPORT_PCRE8 */
833    
834    #ifdef SUPPORT_PCRE32
835    static void setstack32(pcre32_extra *extra)
836    {
837            static pcre32_jit_stack *stack;
838    
839            if (!extra) {
840                    if (stack)
841                            pcre32_jit_stack_free(stack);
842                    stack = NULL;
843                    return;
844            }
845    
846            if (!stack)
847                    stack = pcre32_jit_stack_alloc(1, 1024 * 1024);
848            /* Extra can be NULL. */
849            pcre32_assign_jit_stack(extra, callback32, stack);
850    }
851    #endif /* SUPPORT_PCRE8 */
852    
853  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
854    
855  static int convert_utf8_to_utf16(const char *input, PCRE_UCHAR16 *output, int *offsetmap, int max_length)  static int convert_utf8_to_utf16(const char *input, PCRE_UCHAR16 *output, int *offsetmap, int max_length)
856  {  {
857          unsigned char *iptr = (unsigned char*)input;          unsigned char *iptr = (unsigned char*)input;
858          unsigned short *optr = (unsigned short *)output;          PCRE_UCHAR16 *optr = output;
859          unsigned int c;          unsigned int c;
860    
861          if (max_length == 0)          if (max_length == 0)
# Line 841  static int convert_utf8_to_utf16(const c Line 884  static int convert_utf8_to_utf16(const c
884                          max_length--;                          max_length--;
885                  } else if (max_length <= 2) {                  } else if (max_length <= 2) {
886                          *optr = '\0';                          *optr = '\0';
887                          return (int)(optr - (unsigned short *)output);                          return (int)(optr - output);
888                  } else {                  } else {
889                          c -= 0x10000;                          c -= 0x10000;
890                          *optr++ = 0xd800 | ((c >> 10) & 0x3ff);                          *optr++ = 0xd800 | ((c >> 10) & 0x3ff);
# Line 854  static int convert_utf8_to_utf16(const c Line 897  static int convert_utf8_to_utf16(const c
897          if (offsetmap)          if (offsetmap)
898                  *offsetmap = (int)(iptr - (unsigned char*)input);                  *offsetmap = (int)(iptr - (unsigned char*)input);
899          *optr = '\0';          *optr = '\0';
900          return (int)(optr - (unsigned short *)output);          return (int)(optr - output);
901  }  }
902    
903  static int copy_char8_to_char16(const char *input, PCRE_UCHAR16 *output, int max_length)  static int copy_char8_to_char16(const char *input, PCRE_UCHAR16 *output, int max_length)
904  {  {
905          unsigned char *iptr = (unsigned char*)input;          unsigned char *iptr = (unsigned char*)input;
906          unsigned short *optr = (unsigned short *)output;          PCRE_UCHAR16 *optr = output;
907    
908          if (max_length == 0)          if (max_length == 0)
909                  return 0;                  return 0;
# Line 870  static int copy_char8_to_char16(const ch Line 913  static int copy_char8_to_char16(const ch
913                  max_length--;                  max_length--;
914          }          }
915          *optr = '\0';          *optr = '\0';
916          return (int)(optr - (unsigned short *)output);          return (int)(optr - output);
917  }  }
918    
919  #define REGTEST_MAX_LENGTH 4096  #define REGTEST_MAX_LENGTH16 4096
920  static PCRE_UCHAR16 regtest_buf[REGTEST_MAX_LENGTH];  static PCRE_UCHAR16 regtest_buf16[REGTEST_MAX_LENGTH16];
921  static int regtest_offsetmap[REGTEST_MAX_LENGTH];  static int regtest_offsetmap16[REGTEST_MAX_LENGTH16];
922    
923  #endif /* SUPPORT_PCRE16 */  #endif /* SUPPORT_PCRE16 */
924    
925    #ifdef SUPPORT_PCRE32
926    
927    static int convert_utf8_to_utf32(const char *input, PCRE_UCHAR32 *output, int *offsetmap, int max_length)
928    {
929            unsigned char *iptr = (unsigned char*)input;
930            PCRE_UCHAR32 *optr = output;
931            unsigned int c;
932    
933            if (max_length == 0)
934                    return 0;
935    
936            while (*iptr && max_length > 1) {
937                    c = 0;
938                    if (offsetmap)
939                            *offsetmap++ = (int)(iptr - (unsigned char*)input);
940    
941                    if (!(*iptr & 0x80))
942                            c = *iptr++;
943                    else if (!(*iptr & 0x20)) {
944                            c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
945                            iptr += 2;
946                    } else if (!(*iptr & 0x10)) {
947                            c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
948                            iptr += 3;
949                    } else if (!(*iptr & 0x08)) {
950                            c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
951                            iptr += 4;
952                    }
953    
954                    *optr++ = c;
955                    max_length--;
956            }
957            if (offsetmap)
958                    *offsetmap = (int)(iptr - (unsigned char*)input);
959            *optr = 0;
960            return (int)(optr - output);
961    }
962    
963    static int copy_char8_to_char32(const char *input, PCRE_UCHAR32 *output, int max_length)
964    {
965            unsigned char *iptr = (unsigned char*)input;
966            PCRE_UCHAR32 *optr = output;
967    
968            if (max_length == 0)
969                    return 0;
970    
971            while (*iptr && max_length > 1) {
972                    *optr++ = *iptr++;
973                    max_length--;
974            }
975            *optr = '\0';
976            return (int)(optr - output);
977    }
978    
979    #define REGTEST_MAX_LENGTH32 4096
980    static PCRE_UCHAR32 regtest_buf32[REGTEST_MAX_LENGTH32];
981    static int regtest_offsetmap32[REGTEST_MAX_LENGTH32];
982    
983    #endif /* SUPPORT_PCRE32 */
984    
985  static int check_ascii(const char *input)  static int check_ascii(const char *input)
986  {  {
987          const unsigned char *ptr = (unsigned char *)input;          const unsigned char *ptr = (unsigned char *)input;
# Line 902  static int regression_tests(void) Line 1005  static int regression_tests(void)
1005          int successful_row = 0;          int successful_row = 0;
1006          int counter = 0;          int counter = 0;
1007          int study_mode;          int study_mode;
1008            int utf = 0, ucp = 0;
1009            int disabled_flags = 0;
1010  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1011          pcre *re8;          pcre *re8;
1012          pcre_extra *extra8;          pcre_extra *extra8;
1013          pcre_extra dummy_extra8;          pcre_extra dummy_extra8;
1014          int ovector8_1[32];          int ovector8_1[32];
1015          int ovector8_2[32];          int ovector8_2[32];
1016          int return_value8_1, return_value8_2;          int return_value8[2];
1017          unsigned char *mark8_1, *mark8_2;          unsigned char *mark8_1, *mark8_2;
         int utf8 = 0, ucp8 = 0;  
         int disabled_flags8 = 0;  
1018  #endif  #endif
1019  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1020          pcre16 *re16;          pcre16 *re16;
# Line 919  static int regression_tests(void) Line 1022  static int regression_tests(void)
1022          pcre16_extra dummy_extra16;          pcre16_extra dummy_extra16;
1023          int ovector16_1[32];          int ovector16_1[32];
1024          int ovector16_2[32];          int ovector16_2[32];
1025          int return_value16_1, return_value16_2;          int return_value16[2];
1026          PCRE_UCHAR16 *mark16_1, *mark16_2;          PCRE_UCHAR16 *mark16_1, *mark16_2;
         int utf16 = 0, ucp16 = 0;  
         int disabled_flags16 = 0;  
1027          int length16;          int length16;
1028  #endif  #endif
1029    #ifdef SUPPORT_PCRE32
1030            pcre32 *re32;
1031            pcre32_extra *extra32;
1032            pcre32_extra dummy_extra32;
1033            int ovector32_1[32];
1034            int ovector32_2[32];
1035            int return_value32[2];
1036            PCRE_UCHAR32 *mark32_1, *mark32_2;
1037            int length32;
1038    #endif
1039    
1040          /* This test compares the behaviour of interpreter and JIT. Although disabling          /* This test compares the behaviour of interpreter and JIT. Although disabling
1041          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
1042          still considered successful from pcre_jit_test point of view. */          still considered successful from pcre_jit_test point of view. */
1043    
1044  #ifdef SUPPORT_PCRE8  #if defined SUPPORT_PCRE8
1045          pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);          pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1046  #else  #elif defined SUPPORT_PCRE16
1047          pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);          pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1048    #elif defined SUPPORT_PCRE32
1049            pcre32_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1050  #endif  #endif
1051    
1052          printf("Running JIT regression tests\n");          printf("Running JIT regression tests\n");
1053          printf("  target CPU of SLJIT compiler: %s\n", cpu_info);          printf("  target CPU of SLJIT compiler: %s\n", cpu_info);
1054    
1055    #if defined SUPPORT_PCRE8
1056            pcre_config(PCRE_CONFIG_UTF8, &utf);
1057            pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1058    #elif defined SUPPORT_PCRE16
1059            pcre16_config(PCRE_CONFIG_UTF16, &utf);
1060            pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1061    #elif defined SUPPORT_PCRE16
1062            pcre32_config(PCRE_CONFIG_UTF32, &utf);
1063            pcre32_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1064    #endif
1065    
1066            if (!utf)
1067                    disabled_flags |= PCRE_UTF8 | PCRE_UTF16 | PCRE_UTF32;
1068            if (!ucp)
1069                    disabled_flags |= PCRE_UCP;
1070  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1071          pcre_config(PCRE_CONFIG_UTF8, &utf8);          printf("  in  8 bit mode with UTF-8  %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
         pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp8);  
         if (!utf8)  
                 disabled_flags8 |= PCRE_UTF8;  
         if (!ucp8)  
                 disabled_flags8 |= PCRE_UCP;  
         printf("  in  8 bit mode with utf8  %s and ucp %s:\n", utf8 ? "enabled" : "disabled", ucp8 ? "enabled" : "disabled");  
1072  #endif  #endif
1073  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1074          pcre16_config(PCRE_CONFIG_UTF16, &utf16);          printf("  in 16 bit mode with UTF-16 %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
1075          pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp16);  #endif
1076          if (!utf16)  #ifdef SUPPORT_PCRE32
1077                  disabled_flags16 |= PCRE_UTF8;          printf("  in 32 bit mode with UTF-32 %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
         if (!ucp16)  
                 disabled_flags16 |= PCRE_UCP;  
         printf("  in 16 bit mode with utf16 %s and ucp %s:\n", utf16 ? "enabled" : "disabled", ucp16 ? "enabled" : "disabled");  
1078  #endif  #endif
1079    
1080          while (current->pattern) {          while (current->pattern) {
# Line 980  static int regression_tests(void) Line 1099  static int regression_tests(void)
1099                  re8 = NULL;                  re8 = NULL;
1100                  if (!(current->start_offset & F_NO8))                  if (!(current->start_offset & F_NO8))
1101                          re8 = pcre_compile(current->pattern,                          re8 = pcre_compile(current->pattern,
1102                                  current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags8),                                  current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
1103                                  &error, &err_offs, tables(0));                                  &error, &err_offs, tables(0));
1104    
1105                  extra8 = NULL;                  extra8 = NULL;
# Line 992  static int regression_tests(void) Line 1111  static int regression_tests(void)
1111                                  pcre_free(re8);                                  pcre_free(re8);
1112                                  re8 = NULL;                                  re8 = NULL;
1113                          }                          }
1114                          if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {                          else if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1115                                  printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);                                  printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);
1116                                  pcre_free_study(extra8);                                  pcre_free_study(extra8);
1117                                  pcre_free(re8);                                  pcre_free(re8);
1118                                  re8 = NULL;                                  re8 = NULL;
1119                          }                          }
1120                          extra8->flags |= PCRE_EXTRA_MARK;                          extra8->flags |= PCRE_EXTRA_MARK;
1121                  } else if (((utf8 && ucp8) || is_ascii_pattern) && !(current->start_offset & F_NO8))                  } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO8))
1122                          printf("\n8 bit: Cannot compile pattern: %s\n", current->pattern);                          printf("\n8 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1123  #endif  #endif
1124  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1125                  if ((current->flags & PCRE_UTF8) || (current->start_offset & F_FORCECONV))                  if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
1126                          convert_utf8_to_utf16(current->pattern, regtest_buf, NULL, REGTEST_MAX_LENGTH);                          convert_utf8_to_utf16(current->pattern, regtest_buf16, NULL, REGTEST_MAX_LENGTH16);
1127                  else                  else
1128                          copy_char8_to_char16(current->pattern, regtest_buf, REGTEST_MAX_LENGTH);                          copy_char8_to_char16(current->pattern, regtest_buf16, REGTEST_MAX_LENGTH16);
1129    
1130                  re16 = NULL;                  re16 = NULL;
1131                  if (!(current->start_offset & F_NO16))                  if (!(current->start_offset & F_NO16))
1132                          re16 = pcre16_compile(regtest_buf,                          re16 = pcre16_compile(regtest_buf16,
1133                                  current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags16),                                  current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
1134                                  &error, &err_offs, tables(0));                                  &error, &err_offs, tables(0));
1135    
1136                  extra16 = NULL;                  extra16 = NULL;
# Line 1023  static int regression_tests(void) Line 1142  static int regression_tests(void)
1142                                  pcre16_free(re16);                                  pcre16_free(re16);
1143                                  re16 = NULL;                                  re16 = NULL;
1144                          }                          }
1145                          if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {                          else if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1146                                  printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);                                  printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);
1147                                  pcre16_free_study(extra16);                                  pcre16_free_study(extra16);
1148                                  pcre16_free(re16);                                  pcre16_free(re16);
1149                                  re16 = NULL;                                  re16 = NULL;
1150                          }                          }
1151                          extra16->flags |= PCRE_EXTRA_MARK;                          extra16->flags |= PCRE_EXTRA_MARK;
1152                  } else if (((utf16 && ucp16) || is_ascii_pattern) && !(current->start_offset & F_NO16))                  } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO16))
1153                          printf("\n16 bit: Cannot compile pattern: %s\n", current->pattern);                          printf("\n16 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1154    #endif
1155    #ifdef SUPPORT_PCRE32
1156                    if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
1157                            convert_utf8_to_utf32(current->pattern, regtest_buf32, NULL, REGTEST_MAX_LENGTH32);
1158                    else
1159                            copy_char8_to_char32(current->pattern, regtest_buf32, REGTEST_MAX_LENGTH32);
1160    
1161                    re32 = NULL;
1162                    if (!(current->start_offset & F_NO32))
1163                            re32 = pcre32_compile(regtest_buf32,
1164                                    current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
1165                                    &error, &err_offs, tables(0));
1166    
1167                    extra32 = NULL;
1168                    if (re32) {
1169                            error = NULL;
1170                            extra32 = pcre32_study(re32, study_mode, &error);
1171                            if (!extra32) {
1172                                    printf("\n32 bit: Cannot study pattern: %s\n", current->pattern);
1173                                    pcre32_free(re32);
1174                                    re32 = NULL;
1175                            }
1176                            if (!(extra32->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1177                                    printf("\n32 bit: JIT compiler does not support: %s\n", current->pattern);
1178                                    pcre32_free_study(extra32);
1179                                    pcre32_free(re32);
1180                                    re32 = NULL;
1181                            }
1182                            extra32->flags |= PCRE_EXTRA_MARK;
1183                    } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO32))
1184                            printf("\n32 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1185  #endif  #endif
1186    
1187                  counter++;                  counter++;
# Line 1042  static int regression_tests(void) Line 1192  static int regression_tests(void)
1192  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1193                          setstack16(NULL);                          setstack16(NULL);
1194  #endif  #endif
1195    #ifdef SUPPORT_PCRE32
1196                            setstack32(NULL);
1197    #endif
1198                  }                  }
1199    
1200  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1201                  return_value8_1 = -1000;                  return_value8[0] = -1000;
1202                  return_value8_2 = -1000;                  return_value8[1] = -1000;
1203                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
1204                          ovector8_1[i] = -2;                          ovector8_1[i] = -2;
1205                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
# Line 1056  static int regression_tests(void) Line 1209  static int regression_tests(void)
1209                          mark8_2 = NULL;                          mark8_2 = NULL;
1210                          setstack8(extra8);                          setstack8(extra8);
1211                          extra8->mark = &mark8_1;                          extra8->mark = &mark8_1;
1212                          return_value8_1 = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,                          return_value8[0] = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1213                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32);                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32);
1214                          memset(&dummy_extra8, 0, sizeof(pcre_extra));                          memset(&dummy_extra8, 0, sizeof(pcre_extra));
1215                          dummy_extra8.flags = PCRE_EXTRA_MARK;                          dummy_extra8.flags = PCRE_EXTRA_MARK;
1216                          dummy_extra8.mark = &mark8_2;                          dummy_extra8.mark = &mark8_2;
1217                          return_value8_2 = pcre_exec(re8, &dummy_extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,                          return_value8[1] = pcre_exec(re8, &dummy_extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1218                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_2, 32);                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_2, 32);
1219                  }                  }
1220  #endif  #endif
1221    
1222  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1223                  return_value16_1 = -1000;                  return_value16[0] = -1000;
1224                  return_value16_2 = -1000;                  return_value16[1] = -1000;
1225                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
1226                          ovector16_1[i] = -2;                          ovector16_1[i] = -2;
1227                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
# Line 1077  static int regression_tests(void) Line 1230  static int regression_tests(void)
1230                          mark16_1 = NULL;                          mark16_1 = NULL;
1231                          mark16_2 = NULL;                          mark16_2 = NULL;
1232                          setstack16(extra16);                          setstack16(extra16);
1233                          if ((current->flags & PCRE_UTF8) || (current->start_offset & F_FORCECONV))                          if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
1234                                  length16 = convert_utf8_to_utf16(current->input, regtest_buf, regtest_offsetmap, REGTEST_MAX_LENGTH);                                  length16 = convert_utf8_to_utf16(current->input, regtest_buf16, regtest_offsetmap16, REGTEST_MAX_LENGTH16);
1235                          else                          else
1236                                  length16 = copy_char8_to_char16(current->input, regtest_buf, REGTEST_MAX_LENGTH);                                  length16 = copy_char8_to_char16(current->input, regtest_buf16, REGTEST_MAX_LENGTH16);
1237                          extra16->mark = &mark16_1;                          extra16->mark = &mark16_1;
1238                          return_value16_1 = pcre16_exec(re16, extra16, regtest_buf, length16, current->start_offset & OFFSET_MASK,                          return_value16[0] = pcre16_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1239                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32);                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32);
1240                          memset(&dummy_extra16, 0, sizeof(pcre16_extra));                          memset(&dummy_extra16, 0, sizeof(pcre16_extra));
1241                          dummy_extra16.flags = PCRE_EXTRA_MARK;                          dummy_extra16.flags = PCRE_EXTRA_MARK;
1242                          dummy_extra16.mark = &mark16_2;                          dummy_extra16.mark = &mark16_2;
1243                          return_value16_2 = pcre16_exec(re16, &dummy_extra16, regtest_buf, length16, current->start_offset & OFFSET_MASK,                          return_value16[1] = pcre16_exec(re16, &dummy_extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1244                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_2, 32);                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_2, 32);
1245                  }                  }
1246  #endif  #endif
1247    
1248                  /* 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" : ""); */  #ifdef SUPPORT_PCRE32
1249                    return_value32[0] = -1000;
1250                    return_value32[1] = -1000;
1251                    for (i = 0; i < 32; ++i)
1252                            ovector32_1[i] = -2;
1253                    for (i = 0; i < 32; ++i)
1254                            ovector32_2[i] = -2;
1255                    if (re32) {
1256                            mark32_1 = NULL;
1257                            mark32_2 = NULL;
1258                            setstack32(extra32);
1259                            if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
1260                                    length32 = convert_utf8_to_utf32(current->input, regtest_buf32, regtest_offsetmap32, REGTEST_MAX_LENGTH32);
1261                            else
1262                                    length32 = copy_char8_to_char32(current->input, regtest_buf32, REGTEST_MAX_LENGTH32);
1263                            extra32->mark = &mark32_1;
1264                            return_value32[0] = pcre32_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1265                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_1, 32);
1266                            memset(&dummy_extra32, 0, sizeof(pcre32_extra));
1267                            dummy_extra32.flags = PCRE_EXTRA_MARK;
1268                            dummy_extra32.mark = &mark32_2;
1269                            return_value32[1] = pcre32_exec(re32, &dummy_extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1270                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_2, 32);
1271                    }
1272    #endif
1273    
1274                    /* printf("[%d-%d-%d|%d-%d|%d-%d|%d-%d]%s",
1275                     *        return_value8[0], return_value16[0],
1276                     *        ovector8_1[0], ovector8_1[1],
1277                     *        ovector16_1[0], ovector16_1[1],
1278                     *        ovector32_1[0], ovector32_1[1],
1279                     *        (current->flags & PCRE_CASELESS) ? "C" : ""); */
1280    
1281                  /* 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.
1282                  Segfaults can still be captured. */                  Segfaults can still be captured. */
1283    
1284                  is_successful = 1;                  is_successful = 1;
1285                  if (!(current->start_offset & F_DIFF)) {                  if (!(current->start_offset & F_DIFF)) {
1286  #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16  #if defined SUPPORT_UTF && ((defined(SUPPORT_PCRE8) + defined(SUPPORT_PCRE16) + defined(SUPPORT_PCRE32)) >= 2)
1287                          if (utf8 == utf16 && !(current->start_offset & F_FORCECONV)) {                          if (!(current->start_offset & F_FORCECONV)) {
1288                                    int return_value;
1289    
1290                                  /* All results must be the same. */                                  /* All results must be the same. */
1291                                  if (return_value8_1 != return_value8_2 || return_value8_1 != return_value16_1 || return_value8_1 != return_value16_2) {  #ifdef SUPPORT_PCRE8
1292                                          printf("\n8 and 16 bit: Return value differs(%d:%d:%d:%d): [%d] '%s' @ '%s'\n",                                  if ((return_value = return_value8[0]) != return_value8[1]) {
1293                                                  return_value8_1, return_value8_2, return_value16_1, return_value16_2,                                          printf("\n8 bit: Return value differs(J8:%d,I8:%d): [%d] '%s' @ '%s'\n",
1294                                                    return_value8[0], return_value8[1], total, current->pattern, current->input);
1295                                            is_successful = 0;
1296                                    } else
1297    #endif
1298    #ifdef SUPPORT_PCRE16
1299                                    if ((return_value = return_value16[0]) != return_value16[1]) {
1300                                            printf("\n16 bit: Return value differs(J16:%d,I16:%d): [%d] '%s' @ '%s'\n",
1301                                                    return_value16[0], return_value16[1], total, current->pattern, current->input);
1302                                            is_successful = 0;
1303                                    } else
1304    #endif
1305    #ifdef SUPPORT_PCRE32
1306                                    if ((return_value = return_value32[0]) != return_value32[1]) {
1307                                            printf("\n32 bit: Return value differs(J32:%d,I32:%d): [%d] '%s' @ '%s'\n",
1308                                                    return_value32[0], return_value32[1], total, current->pattern, current->input);
1309                                            is_successful = 0;
1310                                    } else
1311    #endif
1312    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
1313                                    if (return_value8[0] != return_value16[0]) {
1314                                            printf("\n8 and 16 bit: Return value differs(J8:%d,J16:%d): [%d] '%s' @ '%s'\n",
1315                                                    return_value8[0], return_value16[0],
1316                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1317                                          is_successful = 0;                                          is_successful = 0;
1318                                  } else if (return_value8_1 >= 0 || return_value8_1 == PCRE_ERROR_PARTIAL) {                                  } else
1319                                          if (return_value8_1 == PCRE_ERROR_PARTIAL) {  #endif
1320                                                  return_value8_1 = 2;  #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
1321                                                  return_value16_1 = 2;                                  if (return_value8[0] != return_value32[0]) {
1322                                            printf("\n8 and 32 bit: Return value differs(J8:%d,J32:%d): [%d] '%s' @ '%s'\n",
1323                                                    return_value8[0], return_value32[0],
1324                                                    total, current->pattern, current->input);
1325                                            is_successful = 0;
1326                                    } else
1327    #endif
1328    #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE32
1329                                    if (return_value16[0] != return_value32[0]) {
1330                                            printf("\n16 and 32 bit: Return value differs(J16:%d,J32:%d): [%d] '%s' @ '%s'\n",
1331                                                    return_value16[0], return_value32[0],
1332                                                    total, current->pattern, current->input);
1333                                            is_successful = 0;
1334                                    } else
1335    #endif
1336                                    if (return_value >= 0 || return_value == PCRE_ERROR_PARTIAL) {
1337                                            if (return_value == PCRE_ERROR_PARTIAL) {
1338                                                    return_value = 2;
1339                                          } else {                                          } else {
1340                                                  return_value8_1 *= 2;                                                  return_value *= 2;
                                                 return_value16_1 *= 2;  
1341                                          }                                          }
1342    #ifdef SUPPORT_PCRE8
1343                                            return_value8[0] = return_value;
1344    #endif
1345    #ifdef SUPPORT_PCRE16
1346                                            return_value16[0] = return_value;
1347    #endif
1348    #ifdef SUPPORT_PCRE32
1349                                            return_value32[0] = return_value;
1350    #endif
1351                                          /* Transform back the results. */                                          /* Transform back the results. */
1352                                          if (current->flags & PCRE_UTF8) {                                          if (current->flags & PCRE_UTF8) {
1353                                                  for (i = 0; i < return_value8_1; ++i) {  #ifdef SUPPORT_PCRE16
1354                                                    for (i = 0; i < return_value; ++i) {
1355                                                          if (ovector16_1[i] >= 0)                                                          if (ovector16_1[i] >= 0)
1356                                                                  ovector16_1[i] = regtest_offsetmap[ovector16_1[i]];                                                                  ovector16_1[i] = regtest_offsetmap16[ovector16_1[i]];
1357                                                          if (ovector16_2[i] >= 0)                                                          if (ovector16_2[i] >= 0)
1358                                                                  ovector16_2[i] = regtest_offsetmap[ovector16_2[i]];                                                                  ovector16_2[i] = regtest_offsetmap16[ovector16_2[i]];
1359                                                  }                                                  }
1360                                          }  #endif
1361    #ifdef SUPPORT_PCRE32
1362                                                    for (i = 0; i < return_value; ++i) {
1363                                                            if (ovector32_1[i] >= 0)
1364                                                                    ovector32_1[i] = regtest_offsetmap32[ovector32_1[i]];
1365                                                            if (ovector32_2[i] >= 0)
1366                                                                    ovector32_2[i] = regtest_offsetmap32[ovector32_2[i]];
1367                                                    }
1368    #endif
1369                                            }
1370    
1371                                          for (i = 0; i < return_value8_1; ++i)                                          for (i = 0; i < return_value; ++i) {
1372    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
1373                                                  if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector16_1[i] || ovector8_1[i] != ovector16_2[i]) {                                                  if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector16_1[i] || ovector8_1[i] != ovector16_2[i]) {
1374                                                          printf("\n8 and 16 bit: Ovector[%d] value differs(%d:%d:%d:%d): [%d] '%s' @ '%s' \n",                                                          printf("\n8 and 16 bit: Ovector[%d] value differs(J8:%d,I8:%d,J16:%d,I16:%d): [%d] '%s' @ '%s' \n",
1375                                                                  i, ovector8_1[i], ovector8_2[i], ovector16_1[i], ovector16_2[i],                                                                  i, ovector8_1[i], ovector8_2[i], ovector16_1[i], ovector16_2[i],
1376                                                                  total, current->pattern, current->input);                                                                  total, current->pattern, current->input);
1377                                                          is_successful = 0;                                                          is_successful = 0;
1378                                                  }                                                  }
1379    #endif
1380    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
1381                                                    if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector32_1[i] || ovector8_1[i] != ovector32_2[i]) {
1382                                                            printf("\n8 and 32 bit: Ovector[%d] value differs(J8:%d,I8:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
1383                                                                    i, ovector8_1[i], ovector8_2[i], ovector32_1[i], ovector32_2[i],
1384                                                                    total, current->pattern, current->input);
1385                                                            is_successful = 0;
1386                                                    }
1387    #endif
1388    #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE16
1389                                                    if (ovector16_1[i] != ovector16_2[i] || ovector16_1[i] != ovector16_1[i] || ovector16_1[i] != ovector16_2[i]) {
1390                                                            printf("\n16 and 16 bit: Ovector[%d] value differs(J16:%d,I16:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
1391                                                                    i, ovector16_1[i], ovector16_2[i], ovector16_1[i], ovector16_2[i],
1392                                                                    total, current->pattern, current->input);
1393                                                            is_successful = 0;
1394                                                    }
1395    #endif
1396                                            }
1397                                  }                                  }
1398                          } else {                          } else
1399  #endif /* SUPPORT_PCRE8 && SUPPORT_PCRE16 */  #endif /* more than one of SUPPORT_PCRE8, SUPPORT_PCRE16 and SUPPORT_PCRE32 */
1400                            {
1401                                  /* Only the 8 bit and 16 bit results must be equal. */                                  /* Only the 8 bit and 16 bit results must be equal. */
1402  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1403                                  if (return_value8_1 != return_value8_2) {                                  if (return_value8[0] != return_value8[1]) {
1404                                          printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",                                          printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1405                                                  return_value8_1, return_value8_2, total, current->pattern, current->input);                                                  return_value8[0], return_value8[1], total, current->pattern, current->input);
1406                                          is_successful = 0;                                          is_successful = 0;
1407                                  } else if (return_value8_1 >= 0 || return_value8_1 == PCRE_ERROR_PARTIAL) {                                  } else if (return_value8[0] >= 0 || return_value8[0] == PCRE_ERROR_PARTIAL) {
1408                                          if (return_value8_1 == PCRE_ERROR_PARTIAL)                                          if (return_value8[0] == PCRE_ERROR_PARTIAL)
1409                                                  return_value8_1 = 2;                                                  return_value8[0] = 2;
1410                                          else                                          else
1411                                                  return_value8_1 *= 2;                                                  return_value8[0] *= 2;
1412    
1413                                          for (i = 0; i < return_value8_1; ++i)                                          for (i = 0; i < return_value8[0]; ++i)
1414                                                  if (ovector8_1[i] != ovector8_2[i]) {                                                  if (ovector8_1[i] != ovector8_2[i]) {
1415                                                          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",
1416                                                                  i, ovector8_1[i], ovector8_2[i], total, current->pattern, current->input);                                                                  i, ovector8_1[i], ovector8_2[i], total, current->pattern, current->input);
# Line 1158  static int regression_tests(void) Line 1420  static int regression_tests(void)
1420  #endif  #endif
1421    
1422  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1423                                  if (return_value16_1 != return_value16_2) {                                  if (return_value16[0] != return_value16[1]) {
1424                                          printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",                                          printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1425                                                  return_value16_1, return_value16_2, total, current->pattern, current->input);                                                  return_value16[0], return_value16[1], total, current->pattern, current->input);
1426                                          is_successful = 0;                                          is_successful = 0;
1427                                  } else if (return_value16_1 >= 0 || return_value16_1 == PCRE_ERROR_PARTIAL) {                                  } else if (return_value16[0] >= 0 || return_value16[0] == PCRE_ERROR_PARTIAL) {
1428                                          if (return_value16_1 == PCRE_ERROR_PARTIAL)                                          if (return_value16[0] == PCRE_ERROR_PARTIAL)
1429                                                  return_value16_1 = 2;                                                  return_value16[0] = 2;
1430                                          else                                          else
1431                                                  return_value16_1 *= 2;                                                  return_value16[0] *= 2;
1432    
1433                                          for (i = 0; i < return_value16_1; ++i)                                          for (i = 0; i < return_value16[0]; ++i)
1434                                                  if (ovector16_1[i] != ovector16_2[i]) {                                                  if (ovector16_1[i] != ovector16_2[i]) {
1435                                                          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",
1436                                                                  i, ovector16_1[i], ovector16_2[i], total, current->pattern, current->input);                                                                  i, ovector16_1[i], ovector16_2[i], total, current->pattern, current->input);
# Line 1177  static int regression_tests(void) Line 1439  static int regression_tests(void)
1439                                  }                                  }
1440  #endif  #endif
1441    
1442  #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16  #ifdef SUPPORT_PCRE32
1443                          }                                  if (return_value32[0] != return_value32[1]) {
1444  #endif /* SUPPORT_PCRE8 && SUPPORT_PCRE16 */                                          printf("\n32 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1445                                                    return_value32[0], return_value32[1], total, current->pattern, current->input);
1446                                            is_successful = 0;
1447                                    } else if (return_value32[0] >= 0 || return_value32[0] == PCRE_ERROR_PARTIAL) {
1448                                            if (return_value32[0] == PCRE_ERROR_PARTIAL)
1449                                                    return_value32[0] = 2;
1450                                            else
1451                                                    return_value32[0] *= 2;
1452    
1453                                            for (i = 0; i < return_value32[0]; ++i)
1454                                                    if (ovector32_1[i] != ovector32_2[i]) {
1455                                                            printf("\n32 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
1456                                                                    i, ovector32_1[i], ovector32_2[i], total, current->pattern, current->input);
1457                                                            is_successful = 0;
1458                                                    }
1459                                    }
1460    #endif
1461                            }
1462                  }                  }
1463    
1464                  if (is_successful) {                  if (is_successful) {
1465  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1466                          if (!(current->start_offset & F_NO8) && ((utf8 && ucp8) || is_ascii_input)) {                          if (!(current->start_offset & F_NO8) && ((utf && ucp) || is_ascii_input)) {
1467                                  if (return_value8_1 < 0 && !(current->start_offset & F_NOMATCH)) {                                  if (return_value8[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1468                                          printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",                                          printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",
1469                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1470                                          is_successful = 0;                                          is_successful = 0;
1471                                  }                                  }
1472    
1473                                  if (return_value8_1 >= 0 && (current->start_offset & F_NOMATCH)) {                                  if (return_value8[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1474                                          printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",                                          printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",
1475                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1476                                          is_successful = 0;                                          is_successful = 0;
# Line 1199  static int regression_tests(void) Line 1478  static int regression_tests(void)
1478                          }                          }
1479  #endif  #endif
1480  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1481                          if (!(current->start_offset & F_NO16) && ((utf16 && ucp16) || is_ascii_input)) {                          if (!(current->start_offset & F_NO16) && ((utf && ucp) || is_ascii_input)) {
1482                                  if (return_value16_1 < 0 && !(current->start_offset & F_NOMATCH)) {                                  if (return_value16[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1483                                          printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",                                          printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",
1484                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1485                                          is_successful = 0;                                          is_successful = 0;
1486                                  }                                  }
1487    
1488                                  if (return_value16_1 >= 0 && (current->start_offset & F_NOMATCH)) {                                  if (return_value16[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1489                                          printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",                                          printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",
1490                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1491                                          is_successful = 0;                                          is_successful = 0;
1492                                  }                                  }
1493                          }                          }
1494  #endif  #endif
1495    #ifdef SUPPORT_PCRE32
1496                            if (!(current->start_offset & F_NO32) && ((utf && ucp) || is_ascii_input)) {
1497                                    if (return_value32[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1498                                            printf("32 bit: Test should match: [%d] '%s' @ '%s'\n",
1499                                                    total, current->pattern, current->input);
1500                                            is_successful = 0;
1501                                    }
1502    
1503                                    if (return_value32[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1504                                            printf("32 bit: Test should not match: [%d] '%s' @ '%s'\n",
1505                                                    total, current->pattern, current->input);
1506                                            is_successful = 0;
1507                                    }
1508                            }
1509    #endif
1510                  }                  }
1511    
1512                  if (is_successful) {                  if (is_successful) {
# Line 1230  static int regression_tests(void) Line 1524  static int regression_tests(void)
1524                                  is_successful = 0;                                  is_successful = 0;
1525                          }                          }
1526  #endif  #endif
1527    #ifdef SUPPORT_PCRE32
1528                            if (mark32_1 != mark32_2) {
1529                                    printf("32 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1530                                            total, current->pattern, current->input);
1531                                    is_successful = 0;
1532                            }
1533    #endif
1534                  }                  }
1535    
1536  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
# Line 1244  static int regression_tests(void) Line 1545  static int regression_tests(void)
1545                          pcre16_free(re16);                          pcre16_free(re16);
1546                  }                  }
1547  #endif  #endif
1548    #ifdef SUPPORT_PCRE32
1549                    if (re32) {
1550                            pcre32_free_study(extra32);
1551                            pcre32_free(re32);
1552                    }
1553    #endif
1554    
1555                  if (is_successful) {                  if (is_successful) {
1556                          successful++;                          successful++;
# Line 1266  static int regression_tests(void) Line 1573  static int regression_tests(void)
1573  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1574          setstack16(NULL);          setstack16(NULL);
1575  #endif  #endif
1576    #ifdef SUPPORT_PCRE32
1577            setstack32(NULL);
1578    #endif
1579    
1580          if (total == successful) {          if (total == successful) {
1581                  printf("\nAll JIT regression tests are successfully passed.\n");                  printf("\nAll JIT regression tests are successfully passed.\n");

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

  ViewVC Help
Powered by ViewVC 1.1.5