/[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 1188 by zherczeg, Mon Oct 29 16:25:25 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 pcre_jit_stack *stack8;
798    
799    static pcre_jit_stack *getstack8(void)
800  {  {
801          static pcre_jit_stack *stack;          if (!stack8)
802                    stack8 = pcre_jit_stack_alloc(1, 1024 * 1024);
803            return stack8;
804    }
805    
806    static void setstack8(pcre_extra *extra)
807    {
808          if (!extra) {          if (!extra) {
809                  if (stack)                  if (stack8)
810                          pcre_jit_stack_free(stack);                          pcre_jit_stack_free(stack8);
811                  stack = NULL;                  stack8 = NULL;
812                  return;                  return;
813          }          }
814    
815          if (!stack)          pcre_assign_jit_stack(extra, callback8, getstack8());
                 stack = pcre_jit_stack_alloc(1, 1024 * 1024);  
         /* Extra can be NULL. */  
         pcre_assign_jit_stack(extra, callback8, stack);  
816  }  }
817  #endif /* SUPPORT_PCRE8 */  #endif /* SUPPORT_PCRE8 */
818    
819  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
820    static pcre16_jit_stack *stack16;
821    
822    static pcre16_jit_stack *getstack16(void)
823    {
824            if (!stack16)
825                    stack16 = pcre16_jit_stack_alloc(1, 1024 * 1024);
826            return stack16;
827    }
828    
829  static void setstack16(pcre16_extra *extra)  static void setstack16(pcre16_extra *extra)
830  {  {
831          static pcre16_jit_stack *stack;          if (!extra) {
832                    if (stack16)
833                            pcre16_jit_stack_free(stack16);
834                    stack16 = NULL;
835                    return;
836            }
837    
838            pcre16_assign_jit_stack(extra, callback16, getstack16());
839    }
840    #endif /* SUPPORT_PCRE8 */
841    
842    #ifdef SUPPORT_PCRE32
843    static pcre32_jit_stack *stack32;
844    
845    static pcre32_jit_stack *getstack32(void)
846    {
847            if (!stack32)
848                    stack32 = pcre32_jit_stack_alloc(1, 1024 * 1024);
849            return stack32;
850    }
851    
852    static void setstack32(pcre32_extra *extra)
853    {
854          if (!extra) {          if (!extra) {
855                  if (stack)                  if (stack32)
856                          pcre16_jit_stack_free(stack);                          pcre32_jit_stack_free(stack32);
857                  stack = NULL;                  stack32 = NULL;
858                  return;                  return;
859          }          }
860    
861          if (!stack)          pcre32_assign_jit_stack(extra, callback32, getstack32());
                 stack = pcre16_jit_stack_alloc(1, 1024 * 1024);  
         /* Extra can be NULL. */  
         pcre16_assign_jit_stack(extra, callback16, stack);  
862  }  }
863  #endif /* SUPPORT_PCRE8 */  #endif /* SUPPORT_PCRE8 */
864    
# Line 812  static void setstack16(pcre16_extra *ext Line 867  static void setstack16(pcre16_extra *ext
867  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)
868  {  {
869          unsigned char *iptr = (unsigned char*)input;          unsigned char *iptr = (unsigned char*)input;
870          unsigned short *optr = (unsigned short *)output;          PCRE_UCHAR16 *optr = output;
871          unsigned int c;          unsigned int c;
872    
873          if (max_length == 0)          if (max_length == 0)
# Line 841  static int convert_utf8_to_utf16(const c Line 896  static int convert_utf8_to_utf16(const c
896                          max_length--;                          max_length--;
897                  } else if (max_length <= 2) {                  } else if (max_length <= 2) {
898                          *optr = '\0';                          *optr = '\0';
899                          return (int)(optr - (unsigned short *)output);                          return (int)(optr - output);
900                  } else {                  } else {
901                          c -= 0x10000;                          c -= 0x10000;
902                          *optr++ = 0xd800 | ((c >> 10) & 0x3ff);                          *optr++ = 0xd800 | ((c >> 10) & 0x3ff);
# Line 854  static int convert_utf8_to_utf16(const c Line 909  static int convert_utf8_to_utf16(const c
909          if (offsetmap)          if (offsetmap)
910                  *offsetmap = (int)(iptr - (unsigned char*)input);                  *offsetmap = (int)(iptr - (unsigned char*)input);
911          *optr = '\0';          *optr = '\0';
912          return (int)(optr - (unsigned short *)output);          return (int)(optr - output);
913  }  }
914    
915  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)
916  {  {
917          unsigned char *iptr = (unsigned char*)input;          unsigned char *iptr = (unsigned char*)input;
918          unsigned short *optr = (unsigned short *)output;          PCRE_UCHAR16 *optr = output;
919    
920          if (max_length == 0)          if (max_length == 0)
921                  return 0;                  return 0;
# Line 870  static int copy_char8_to_char16(const ch Line 925  static int copy_char8_to_char16(const ch
925                  max_length--;                  max_length--;
926          }          }
927          *optr = '\0';          *optr = '\0';
928          return (int)(optr - (unsigned short *)output);          return (int)(optr - output);
929  }  }
930    
931  #define REGTEST_MAX_LENGTH 4096  #define REGTEST_MAX_LENGTH16 4096
932  static PCRE_UCHAR16 regtest_buf[REGTEST_MAX_LENGTH];  static PCRE_UCHAR16 regtest_buf16[REGTEST_MAX_LENGTH16];
933  static int regtest_offsetmap[REGTEST_MAX_LENGTH];  static int regtest_offsetmap16[REGTEST_MAX_LENGTH16];
934    
935  #endif /* SUPPORT_PCRE16 */  #endif /* SUPPORT_PCRE16 */
936    
937    #ifdef SUPPORT_PCRE32
938    
939    static int convert_utf8_to_utf32(const char *input, PCRE_UCHAR32 *output, int *offsetmap, int max_length)
940    {
941            unsigned char *iptr = (unsigned char*)input;
942            PCRE_UCHAR32 *optr = output;
943            unsigned int c;
944    
945            if (max_length == 0)
946                    return 0;
947    
948            while (*iptr && max_length > 1) {
949                    c = 0;
950                    if (offsetmap)
951                            *offsetmap++ = (int)(iptr - (unsigned char*)input);
952    
953                    if (!(*iptr & 0x80))
954                            c = *iptr++;
955                    else if (!(*iptr & 0x20)) {
956                            c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
957                            iptr += 2;
958                    } else if (!(*iptr & 0x10)) {
959                            c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
960                            iptr += 3;
961                    } else if (!(*iptr & 0x08)) {
962                            c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
963                            iptr += 4;
964                    }
965    
966                    *optr++ = c;
967                    max_length--;
968            }
969            if (offsetmap)
970                    *offsetmap = (int)(iptr - (unsigned char*)input);
971            *optr = 0;
972            return (int)(optr - output);
973    }
974    
975    static int copy_char8_to_char32(const char *input, PCRE_UCHAR32 *output, int max_length)
976    {
977            unsigned char *iptr = (unsigned char*)input;
978            PCRE_UCHAR32 *optr = output;
979    
980            if (max_length == 0)
981                    return 0;
982    
983            while (*iptr && max_length > 1) {
984                    *optr++ = *iptr++;
985                    max_length--;
986            }
987            *optr = '\0';
988            return (int)(optr - output);
989    }
990    
991    #define REGTEST_MAX_LENGTH32 4096
992    static PCRE_UCHAR32 regtest_buf32[REGTEST_MAX_LENGTH32];
993    static int regtest_offsetmap32[REGTEST_MAX_LENGTH32];
994    
995    #endif /* SUPPORT_PCRE32 */
996    
997  static int check_ascii(const char *input)  static int check_ascii(const char *input)
998  {  {
999          const unsigned char *ptr = (unsigned char *)input;          const unsigned char *ptr = (unsigned char *)input;
# Line 902  static int regression_tests(void) Line 1017  static int regression_tests(void)
1017          int successful_row = 0;          int successful_row = 0;
1018          int counter = 0;          int counter = 0;
1019          int study_mode;          int study_mode;
1020            int utf = 0, ucp = 0;
1021            int disabled_flags = 0;
1022  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1023          pcre *re8;          pcre *re8;
1024          pcre_extra *extra8;          pcre_extra *extra8;
1025          pcre_extra dummy_extra8;          pcre_extra dummy_extra8;
1026          int ovector8_1[32];          int ovector8_1[32];
1027          int ovector8_2[32];          int ovector8_2[32];
1028          int return_value8_1, return_value8_2;          int return_value8[2];
1029          unsigned char *mark8_1, *mark8_2;          unsigned char *mark8_1, *mark8_2;
         int utf8 = 0, ucp8 = 0;  
         int disabled_flags8 = 0;  
1030  #endif  #endif
1031  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1032          pcre16 *re16;          pcre16 *re16;
# Line 919  static int regression_tests(void) Line 1034  static int regression_tests(void)
1034          pcre16_extra dummy_extra16;          pcre16_extra dummy_extra16;
1035          int ovector16_1[32];          int ovector16_1[32];
1036          int ovector16_2[32];          int ovector16_2[32];
1037          int return_value16_1, return_value16_2;          int return_value16[2];
1038          PCRE_UCHAR16 *mark16_1, *mark16_2;          PCRE_UCHAR16 *mark16_1, *mark16_2;
         int utf16 = 0, ucp16 = 0;  
         int disabled_flags16 = 0;  
1039          int length16;          int length16;
1040  #endif  #endif
1041    #ifdef SUPPORT_PCRE32
1042            pcre32 *re32;
1043            pcre32_extra *extra32;
1044            pcre32_extra dummy_extra32;
1045            int ovector32_1[32];
1046            int ovector32_2[32];
1047            int return_value32[2];
1048            PCRE_UCHAR32 *mark32_1, *mark32_2;
1049            int length32;
1050    #endif
1051    
1052          /* This test compares the behaviour of interpreter and JIT. Although disabling          /* This test compares the behaviour of interpreter and JIT. Although disabling
1053          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
1054          still considered successful from pcre_jit_test point of view. */          still considered successful from pcre_jit_test point of view. */
1055    
1056  #ifdef SUPPORT_PCRE8  #if defined SUPPORT_PCRE8
1057          pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);          pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1058  #else  #elif defined SUPPORT_PCRE16
1059          pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);          pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1060    #elif defined SUPPORT_PCRE32
1061            pcre32_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1062  #endif  #endif
1063    
1064          printf("Running JIT regression tests\n");          printf("Running JIT regression tests\n");
1065          printf("  target CPU of SLJIT compiler: %s\n", cpu_info);          printf("  target CPU of SLJIT compiler: %s\n", cpu_info);
1066    
1067    #if defined SUPPORT_PCRE8
1068            pcre_config(PCRE_CONFIG_UTF8, &utf);
1069            pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1070    #elif defined SUPPORT_PCRE16
1071            pcre16_config(PCRE_CONFIG_UTF16, &utf);
1072            pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1073    #elif defined SUPPORT_PCRE16
1074            pcre32_config(PCRE_CONFIG_UTF32, &utf);
1075            pcre32_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1076    #endif
1077    
1078            if (!utf)
1079                    disabled_flags |= PCRE_UTF8 | PCRE_UTF16 | PCRE_UTF32;
1080            if (!ucp)
1081                    disabled_flags |= PCRE_UCP;
1082  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1083          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");  
1084  #endif  #endif
1085  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1086          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");
1087          pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp16);  #endif
1088          if (!utf16)  #ifdef SUPPORT_PCRE32
1089                  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");  
1090  #endif  #endif
1091    
1092          while (current->pattern) {          while (current->pattern) {
# Line 980  static int regression_tests(void) Line 1111  static int regression_tests(void)
1111                  re8 = NULL;                  re8 = NULL;
1112                  if (!(current->start_offset & F_NO8))                  if (!(current->start_offset & F_NO8))
1113                          re8 = pcre_compile(current->pattern,                          re8 = pcre_compile(current->pattern,
1114                                  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),
1115                                  &error, &err_offs, tables(0));                                  &error, &err_offs, tables(0));
1116    
1117                  extra8 = NULL;                  extra8 = NULL;
# Line 992  static int regression_tests(void) Line 1123  static int regression_tests(void)
1123                                  pcre_free(re8);                                  pcre_free(re8);
1124                                  re8 = NULL;                                  re8 = NULL;
1125                          }                          }
1126                          if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {                          else if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1127                                  printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);                                  printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);
1128                                  pcre_free_study(extra8);                                  pcre_free_study(extra8);
1129                                  pcre_free(re8);                                  pcre_free(re8);
1130                                  re8 = NULL;                                  re8 = NULL;
1131                          }                          }
1132                          extra8->flags |= PCRE_EXTRA_MARK;                          extra8->flags |= PCRE_EXTRA_MARK;
1133                  } else if (((utf8 && ucp8) || is_ascii_pattern) && !(current->start_offset & F_NO8))                  } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO8))
1134                          printf("\n8 bit: Cannot compile pattern: %s\n", current->pattern);                          printf("\n8 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1135  #endif  #endif
1136  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1137                  if ((current->flags & PCRE_UTF8) || (current->start_offset & F_FORCECONV))                  if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
1138                          convert_utf8_to_utf16(current->pattern, regtest_buf, NULL, REGTEST_MAX_LENGTH);                          convert_utf8_to_utf16(current->pattern, regtest_buf16, NULL, REGTEST_MAX_LENGTH16);
1139                  else                  else
1140                          copy_char8_to_char16(current->pattern, regtest_buf, REGTEST_MAX_LENGTH);                          copy_char8_to_char16(current->pattern, regtest_buf16, REGTEST_MAX_LENGTH16);
1141    
1142                  re16 = NULL;                  re16 = NULL;
1143                  if (!(current->start_offset & F_NO16))                  if (!(current->start_offset & F_NO16))
1144                          re16 = pcre16_compile(regtest_buf,                          re16 = pcre16_compile(regtest_buf16,
1145                                  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),
1146                                  &error, &err_offs, tables(0));                                  &error, &err_offs, tables(0));
1147    
1148                  extra16 = NULL;                  extra16 = NULL;
# Line 1023  static int regression_tests(void) Line 1154  static int regression_tests(void)
1154                                  pcre16_free(re16);                                  pcre16_free(re16);
1155                                  re16 = NULL;                                  re16 = NULL;
1156                          }                          }
1157                          if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {                          else if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1158                                  printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);                                  printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);
1159                                  pcre16_free_study(extra16);                                  pcre16_free_study(extra16);
1160                                  pcre16_free(re16);                                  pcre16_free(re16);
1161                                  re16 = NULL;                                  re16 = NULL;
1162                          }                          }
1163                          extra16->flags |= PCRE_EXTRA_MARK;                          extra16->flags |= PCRE_EXTRA_MARK;
1164                  } else if (((utf16 && ucp16) || is_ascii_pattern) && !(current->start_offset & F_NO16))                  } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO16))
1165                          printf("\n16 bit: Cannot compile pattern: %s\n", current->pattern);                          printf("\n16 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1166    #endif
1167    #ifdef SUPPORT_PCRE32
1168                    if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
1169                            convert_utf8_to_utf32(current->pattern, regtest_buf32, NULL, REGTEST_MAX_LENGTH32);
1170                    else
1171                            copy_char8_to_char32(current->pattern, regtest_buf32, REGTEST_MAX_LENGTH32);
1172    
1173                    re32 = NULL;
1174                    if (!(current->start_offset & F_NO32))
1175                            re32 = pcre32_compile(regtest_buf32,
1176                                    current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
1177                                    &error, &err_offs, tables(0));
1178    
1179                    extra32 = NULL;
1180                    if (re32) {
1181                            error = NULL;
1182                            extra32 = pcre32_study(re32, study_mode, &error);
1183                            if (!extra32) {
1184                                    printf("\n32 bit: Cannot study pattern: %s\n", current->pattern);
1185                                    pcre32_free(re32);
1186                                    re32 = NULL;
1187                            }
1188                            if (!(extra32->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1189                                    printf("\n32 bit: JIT compiler does not support: %s\n", current->pattern);
1190                                    pcre32_free_study(extra32);
1191                                    pcre32_free(re32);
1192                                    re32 = NULL;
1193                            }
1194                            extra32->flags |= PCRE_EXTRA_MARK;
1195                    } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO32))
1196                            printf("\n32 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1197  #endif  #endif
1198    
1199                  counter++;                  counter++;
# Line 1042  static int regression_tests(void) Line 1204  static int regression_tests(void)
1204  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1205                          setstack16(NULL);                          setstack16(NULL);
1206  #endif  #endif
1207    #ifdef SUPPORT_PCRE32
1208                            setstack32(NULL);
1209    #endif
1210                  }                  }
1211    
1212  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1213                  return_value8_1 = -1000;                  return_value8[0] = -1000;
1214                  return_value8_2 = -1000;                  return_value8[1] = -1000;
1215                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
1216                          ovector8_1[i] = -2;                          ovector8_1[i] = -2;
1217                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
# Line 1054  static int regression_tests(void) Line 1219  static int regression_tests(void)
1219                  if (re8) {                  if (re8) {
1220                          mark8_1 = NULL;                          mark8_1 = NULL;
1221                          mark8_2 = NULL;                          mark8_2 = NULL;
                         setstack8(extra8);  
1222                          extra8->mark = &mark8_1;                          extra8->mark = &mark8_1;
1223                          return_value8_1 = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,  
1224                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32);                          if ((counter & 0x1) != 0) {
1225                                    setstack8(extra8);
1226                                    return_value8[0] = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1227                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32);
1228                            } else
1229                                    return_value8[0] = pcre_jit_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1230                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32, getstack8());
1231                          memset(&dummy_extra8, 0, sizeof(pcre_extra));                          memset(&dummy_extra8, 0, sizeof(pcre_extra));
1232                          dummy_extra8.flags = PCRE_EXTRA_MARK;                          dummy_extra8.flags = PCRE_EXTRA_MARK;
1233                          dummy_extra8.mark = &mark8_2;                          dummy_extra8.mark = &mark8_2;
1234                          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,
1235                                  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);
1236                  }                  }
1237  #endif  #endif
1238    
1239  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1240                  return_value16_1 = -1000;                  return_value16[0] = -1000;
1241                  return_value16_2 = -1000;                  return_value16[1] = -1000;
1242                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
1243                          ovector16_1[i] = -2;                          ovector16_1[i] = -2;
1244                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
# Line 1076  static int regression_tests(void) Line 1246  static int regression_tests(void)
1246                  if (re16) {                  if (re16) {
1247                          mark16_1 = NULL;                          mark16_1 = NULL;
1248                          mark16_2 = NULL;                          mark16_2 = NULL;
1249                          setstack16(extra16);                          if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
1250                          if ((current->flags & PCRE_UTF8) || (current->start_offset & F_FORCECONV))                                  length16 = convert_utf8_to_utf16(current->input, regtest_buf16, regtest_offsetmap16, REGTEST_MAX_LENGTH16);
                                 length16 = convert_utf8_to_utf16(current->input, regtest_buf, regtest_offsetmap, REGTEST_MAX_LENGTH);  
1251                          else                          else
1252                                  length16 = copy_char8_to_char16(current->input, regtest_buf, REGTEST_MAX_LENGTH);                                  length16 = copy_char8_to_char16(current->input, regtest_buf16, REGTEST_MAX_LENGTH16);
1253                          extra16->mark = &mark16_1;                          extra16->mark = &mark16_1;
1254                          return_value16_1 = pcre16_exec(re16, extra16, regtest_buf, length16, current->start_offset & OFFSET_MASK,                          if ((counter & 0x1) != 0) {
1255                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32);                                  setstack16(extra16);
1256                                    return_value16[0] = pcre16_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1257                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32);
1258                            } else
1259                                    return_value16[0] = pcre16_jit_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1260                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32, getstack16());
1261                          memset(&dummy_extra16, 0, sizeof(pcre16_extra));                          memset(&dummy_extra16, 0, sizeof(pcre16_extra));
1262                          dummy_extra16.flags = PCRE_EXTRA_MARK;                          dummy_extra16.flags = PCRE_EXTRA_MARK;
1263                          dummy_extra16.mark = &mark16_2;                          dummy_extra16.mark = &mark16_2;
1264                          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,
1265                                  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);
1266                  }                  }
1267  #endif  #endif
1268    
1269                  /* 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
1270                    return_value32[0] = -1000;
1271                    return_value32[1] = -1000;
1272                    for (i = 0; i < 32; ++i)
1273                            ovector32_1[i] = -2;
1274                    for (i = 0; i < 32; ++i)
1275                            ovector32_2[i] = -2;
1276                    if (re32) {
1277                            mark32_1 = NULL;
1278                            mark32_2 = NULL;
1279                            if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
1280                                    length32 = convert_utf8_to_utf32(current->input, regtest_buf32, regtest_offsetmap32, REGTEST_MAX_LENGTH32);
1281                            else
1282                                    length32 = copy_char8_to_char32(current->input, regtest_buf32, REGTEST_MAX_LENGTH32);
1283                            extra32->mark = &mark32_1;
1284                            if ((counter & 0x1) != 0) {
1285                                    setstack32(extra32);
1286                                    return_value32[0] = pcre32_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1287                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_1, 32);
1288                            } else
1289                                    return_value32[0] = pcre32_jit_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1290                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_1, 32, getstack32());
1291                            memset(&dummy_extra32, 0, sizeof(pcre32_extra));
1292                            dummy_extra32.flags = PCRE_EXTRA_MARK;
1293                            dummy_extra32.mark = &mark32_2;
1294                            return_value32[1] = pcre32_exec(re32, &dummy_extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1295                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_2, 32);
1296                    }
1297    #endif
1298    
1299                    /* printf("[%d-%d-%d|%d-%d|%d-%d|%d-%d]%s",
1300                            return_value8[0], return_value16[0],
1301                            ovector8_1[0], ovector8_1[1],
1302                            ovector16_1[0], ovector16_1[1],
1303                            ovector32_1[0], ovector32_1[1],
1304                            (current->flags & PCRE_CASELESS) ? "C" : ""); */
1305    
1306                  /* 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.
1307                  Segfaults can still be captured. */                  Segfaults can still be captured. */
1308    
1309                  is_successful = 1;                  is_successful = 1;
1310                  if (!(current->start_offset & F_DIFF)) {                  if (!(current->start_offset & F_DIFF)) {
1311  #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16  #if defined SUPPORT_UTF && ((defined(SUPPORT_PCRE8) + defined(SUPPORT_PCRE16) + defined(SUPPORT_PCRE32)) >= 2)
1312                          if (utf8 == utf16 && !(current->start_offset & F_FORCECONV)) {                          if (!(current->start_offset & F_FORCECONV)) {
1313                                    int return_value;
1314    
1315                                  /* All results must be the same. */                                  /* All results must be the same. */
1316                                  if (return_value8_1 != return_value8_2 || return_value8_1 != return_value16_1 || return_value8_1 != return_value16_2) {  #ifdef SUPPORT_PCRE8
1317                                          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]) {
1318                                                  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",
1319                                                    return_value8[0], return_value8[1], total, current->pattern, current->input);
1320                                            is_successful = 0;
1321                                    } else
1322    #endif
1323    #ifdef SUPPORT_PCRE16
1324                                    if ((return_value = return_value16[0]) != return_value16[1]) {
1325                                            printf("\n16 bit: Return value differs(J16:%d,I16:%d): [%d] '%s' @ '%s'\n",
1326                                                    return_value16[0], return_value16[1], total, current->pattern, current->input);
1327                                            is_successful = 0;
1328                                    } else
1329    #endif
1330    #ifdef SUPPORT_PCRE32
1331                                    if ((return_value = return_value32[0]) != return_value32[1]) {
1332                                            printf("\n32 bit: Return value differs(J32:%d,I32:%d): [%d] '%s' @ '%s'\n",
1333                                                    return_value32[0], return_value32[1], total, current->pattern, current->input);
1334                                            is_successful = 0;
1335                                    } else
1336    #endif
1337    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
1338                                    if (return_value8[0] != return_value16[0]) {
1339                                            printf("\n8 and 16 bit: Return value differs(J8:%d,J16:%d): [%d] '%s' @ '%s'\n",
1340                                                    return_value8[0], return_value16[0],
1341                                                    total, current->pattern, current->input);
1342                                            is_successful = 0;
1343                                    } else
1344    #endif
1345    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
1346                                    if (return_value8[0] != return_value32[0]) {
1347                                            printf("\n8 and 32 bit: Return value differs(J8:%d,J32:%d): [%d] '%s' @ '%s'\n",
1348                                                    return_value8[0], return_value32[0],
1349                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1350                                          is_successful = 0;                                          is_successful = 0;
1351                                  } else if (return_value8_1 >= 0 || return_value8_1 == PCRE_ERROR_PARTIAL) {                                  } else
1352                                          if (return_value8_1 == PCRE_ERROR_PARTIAL) {  #endif
1353                                                  return_value8_1 = 2;  #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE32
1354                                                  return_value16_1 = 2;                                  if (return_value16[0] != return_value32[0]) {
1355                                            printf("\n16 and 32 bit: Return value differs(J16:%d,J32:%d): [%d] '%s' @ '%s'\n",
1356                                                    return_value16[0], return_value32[0],
1357                                                    total, current->pattern, current->input);
1358                                            is_successful = 0;
1359                                    } else
1360    #endif
1361                                    if (return_value >= 0 || return_value == PCRE_ERROR_PARTIAL) {
1362                                            if (return_value == PCRE_ERROR_PARTIAL) {
1363                                                    return_value = 2;
1364                                          } else {                                          } else {
1365                                                  return_value8_1 *= 2;                                                  return_value *= 2;
                                                 return_value16_1 *= 2;  
1366                                          }                                          }
1367    #ifdef SUPPORT_PCRE8
1368                                            return_value8[0] = return_value;
1369    #endif
1370    #ifdef SUPPORT_PCRE16
1371                                            return_value16[0] = return_value;
1372    #endif
1373    #ifdef SUPPORT_PCRE32
1374                                            return_value32[0] = return_value;
1375    #endif
1376                                          /* Transform back the results. */                                          /* Transform back the results. */
1377                                          if (current->flags & PCRE_UTF8) {                                          if (current->flags & PCRE_UTF8) {
1378                                                  for (i = 0; i < return_value8_1; ++i) {  #ifdef SUPPORT_PCRE16
1379                                                    for (i = 0; i < return_value; ++i) {
1380                                                          if (ovector16_1[i] >= 0)                                                          if (ovector16_1[i] >= 0)
1381                                                                  ovector16_1[i] = regtest_offsetmap[ovector16_1[i]];                                                                  ovector16_1[i] = regtest_offsetmap16[ovector16_1[i]];
1382                                                          if (ovector16_2[i] >= 0)                                                          if (ovector16_2[i] >= 0)
1383                                                                  ovector16_2[i] = regtest_offsetmap[ovector16_2[i]];                                                                  ovector16_2[i] = regtest_offsetmap16[ovector16_2[i]];
1384                                                  }                                                  }
1385    #endif
1386    #ifdef SUPPORT_PCRE32
1387                                                    for (i = 0; i < return_value; ++i) {
1388                                                            if (ovector32_1[i] >= 0)
1389                                                                    ovector32_1[i] = regtest_offsetmap32[ovector32_1[i]];
1390                                                            if (ovector32_2[i] >= 0)
1391                                                                    ovector32_2[i] = regtest_offsetmap32[ovector32_2[i]];
1392                                                    }
1393    #endif
1394                                          }                                          }
1395    
1396                                          for (i = 0; i < return_value8_1; ++i)                                          for (i = 0; i < return_value; ++i) {
1397    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
1398                                                  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]) {
1399                                                          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",
1400                                                                  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],
1401                                                                  total, current->pattern, current->input);                                                                  total, current->pattern, current->input);
1402                                                          is_successful = 0;                                                          is_successful = 0;
1403                                                  }                                                  }
1404    #endif
1405    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
1406                                                    if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector32_1[i] || ovector8_1[i] != ovector32_2[i]) {
1407                                                            printf("\n8 and 32 bit: Ovector[%d] value differs(J8:%d,I8:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
1408                                                                    i, ovector8_1[i], ovector8_2[i], ovector32_1[i], ovector32_2[i],
1409                                                                    total, current->pattern, current->input);
1410                                                            is_successful = 0;
1411                                                    }
1412    #endif
1413    #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE16
1414                                                    if (ovector16_1[i] != ovector16_2[i] || ovector16_1[i] != ovector16_1[i] || ovector16_1[i] != ovector16_2[i]) {
1415                                                            printf("\n16 and 16 bit: Ovector[%d] value differs(J16:%d,I16:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
1416                                                                    i, ovector16_1[i], ovector16_2[i], ovector16_1[i], ovector16_2[i],
1417                                                                    total, current->pattern, current->input);
1418                                                            is_successful = 0;
1419                                                    }
1420    #endif
1421                                            }
1422                                  }                                  }
1423                          } else {                          } else
1424  #endif /* SUPPORT_PCRE8 && SUPPORT_PCRE16 */  #endif /* more than one of SUPPORT_PCRE8, SUPPORT_PCRE16 and SUPPORT_PCRE32 */
1425                            {
1426                                  /* Only the 8 bit and 16 bit results must be equal. */                                  /* Only the 8 bit and 16 bit results must be equal. */
1427  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1428                                  if (return_value8_1 != return_value8_2) {                                  if (return_value8[0] != return_value8[1]) {
1429                                          printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",                                          printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1430                                                  return_value8_1, return_value8_2, total, current->pattern, current->input);                                                  return_value8[0], return_value8[1], total, current->pattern, current->input);
1431                                          is_successful = 0;                                          is_successful = 0;
1432                                  } else if (return_value8_1 >= 0 || return_value8_1 == PCRE_ERROR_PARTIAL) {                                  } else if (return_value8[0] >= 0 || return_value8[0] == PCRE_ERROR_PARTIAL) {
1433                                          if (return_value8_1 == PCRE_ERROR_PARTIAL)                                          if (return_value8[0] == PCRE_ERROR_PARTIAL)
1434                                                  return_value8_1 = 2;                                                  return_value8[0] = 2;
1435                                          else                                          else
1436                                                  return_value8_1 *= 2;                                                  return_value8[0] *= 2;
1437    
1438                                          for (i = 0; i < return_value8_1; ++i)                                          for (i = 0; i < return_value8[0]; ++i)
1439                                                  if (ovector8_1[i] != ovector8_2[i]) {                                                  if (ovector8_1[i] != ovector8_2[i]) {
1440                                                          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",
1441                                                                  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 1445  static int regression_tests(void)
1445  #endif  #endif
1446    
1447  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1448                                  if (return_value16_1 != return_value16_2) {                                  if (return_value16[0] != return_value16[1]) {
1449                                          printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",                                          printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1450                                                  return_value16_1, return_value16_2, total, current->pattern, current->input);                                                  return_value16[0], return_value16[1], total, current->pattern, current->input);
1451                                          is_successful = 0;                                          is_successful = 0;
1452                                  } else if (return_value16_1 >= 0 || return_value16_1 == PCRE_ERROR_PARTIAL) {                                  } else if (return_value16[0] >= 0 || return_value16[0] == PCRE_ERROR_PARTIAL) {
1453                                          if (return_value16_1 == PCRE_ERROR_PARTIAL)                                          if (return_value16[0] == PCRE_ERROR_PARTIAL)
1454                                                  return_value16_1 = 2;                                                  return_value16[0] = 2;
1455                                          else                                          else
1456                                                  return_value16_1 *= 2;                                                  return_value16[0] *= 2;
1457    
1458                                          for (i = 0; i < return_value16_1; ++i)                                          for (i = 0; i < return_value16[0]; ++i)
1459                                                  if (ovector16_1[i] != ovector16_2[i]) {                                                  if (ovector16_1[i] != ovector16_2[i]) {
1460                                                          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",
1461                                                                  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 1464  static int regression_tests(void)
1464                                  }                                  }
1465  #endif  #endif
1466    
1467  #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16  #ifdef SUPPORT_PCRE32
1468                                    if (return_value32[0] != return_value32[1]) {
1469                                            printf("\n32 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1470                                                    return_value32[0], return_value32[1], total, current->pattern, current->input);
1471                                            is_successful = 0;
1472                                    } else if (return_value32[0] >= 0 || return_value32[0] == PCRE_ERROR_PARTIAL) {
1473                                            if (return_value32[0] == PCRE_ERROR_PARTIAL)
1474                                                    return_value32[0] = 2;
1475                                            else
1476                                                    return_value32[0] *= 2;
1477    
1478                                            for (i = 0; i < return_value32[0]; ++i)
1479                                                    if (ovector32_1[i] != ovector32_2[i]) {
1480                                                            printf("\n32 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
1481                                                                    i, ovector32_1[i], ovector32_2[i], total, current->pattern, current->input);
1482                                                            is_successful = 0;
1483                                                    }
1484                                    }
1485    #endif
1486                          }                          }
 #endif /* SUPPORT_PCRE8 && SUPPORT_PCRE16 */  
1487                  }                  }
1488    
1489                  if (is_successful) {                  if (is_successful) {
1490  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1491                          if (!(current->start_offset & F_NO8) && ((utf8 && ucp8) || is_ascii_input)) {                          if (!(current->start_offset & F_NO8) && ((utf && ucp) || is_ascii_input)) {
1492                                  if (return_value8_1 < 0 && !(current->start_offset & F_NOMATCH)) {                                  if (return_value8[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1493                                          printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",                                          printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",
1494                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1495                                          is_successful = 0;                                          is_successful = 0;
1496                                  }                                  }
1497    
1498                                  if (return_value8_1 >= 0 && (current->start_offset & F_NOMATCH)) {                                  if (return_value8[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1499                                          printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",                                          printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",
1500                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1501                                          is_successful = 0;                                          is_successful = 0;
# Line 1199  static int regression_tests(void) Line 1503  static int regression_tests(void)
1503                          }                          }
1504  #endif  #endif
1505  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1506                          if (!(current->start_offset & F_NO16) && ((utf16 && ucp16) || is_ascii_input)) {                          if (!(current->start_offset & F_NO16) && ((utf && ucp) || is_ascii_input)) {
1507                                  if (return_value16_1 < 0 && !(current->start_offset & F_NOMATCH)) {                                  if (return_value16[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1508                                          printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",                                          printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",
1509                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1510                                          is_successful = 0;                                          is_successful = 0;
1511                                  }                                  }
1512    
1513                                  if (return_value16_1 >= 0 && (current->start_offset & F_NOMATCH)) {                                  if (return_value16[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1514                                          printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",                                          printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",
1515                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1516                                          is_successful = 0;                                          is_successful = 0;
1517                                  }                                  }
1518                          }                          }
1519  #endif  #endif
1520    #ifdef SUPPORT_PCRE32
1521                            if (!(current->start_offset & F_NO32) && ((utf && ucp) || is_ascii_input)) {
1522                                    if (return_value32[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1523                                            printf("32 bit: Test should match: [%d] '%s' @ '%s'\n",
1524                                                    total, current->pattern, current->input);
1525                                            is_successful = 0;
1526                                    }
1527    
1528                                    if (return_value32[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1529                                            printf("32 bit: Test should not match: [%d] '%s' @ '%s'\n",
1530                                                    total, current->pattern, current->input);
1531                                            is_successful = 0;
1532                                    }
1533                            }
1534    #endif
1535                  }                  }
1536    
1537                  if (is_successful) {                  if (is_successful) {
# Line 1230  static int regression_tests(void) Line 1549  static int regression_tests(void)
1549                                  is_successful = 0;                                  is_successful = 0;
1550                          }                          }
1551  #endif  #endif
1552    #ifdef SUPPORT_PCRE32
1553                            if (mark32_1 != mark32_2) {
1554                                    printf("32 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1555                                            total, current->pattern, current->input);
1556                                    is_successful = 0;
1557                            }
1558    #endif
1559                  }                  }
1560    
1561  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
# Line 1244  static int regression_tests(void) Line 1570  static int regression_tests(void)
1570                          pcre16_free(re16);                          pcre16_free(re16);
1571                  }                  }
1572  #endif  #endif
1573    #ifdef SUPPORT_PCRE32
1574                    if (re32) {
1575                            pcre32_free_study(extra32);
1576                            pcre32_free(re32);
1577                    }
1578    #endif
1579    
1580                  if (is_successful) {                  if (is_successful) {
1581                          successful++;                          successful++;
# Line 1266  static int regression_tests(void) Line 1598  static int regression_tests(void)
1598  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1599          setstack16(NULL);          setstack16(NULL);
1600  #endif  #endif
1601    #ifdef SUPPORT_PCRE32
1602            setstack32(NULL);
1603    #endif
1604    
1605          if (total == successful) {          if (total == successful) {
1606                  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.1188

  ViewVC Help
Powered by ViewVC 1.1.5