/[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 1245 by zherczeg, Sat Feb 9 11:30:51 2013 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
128  #define F_PROPERTY      0x200000  #define F_PROPERTY      0x200000
129    #define F_STUDY         0x400000
130    
131  struct regression_test_case {  struct regression_test_case {
132          int flags;          int flags;
# Line 412  static struct regression_test_case regre Line 419  static struct regression_test_case regre
419          { 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" },
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, "(?>(?:(?>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" },
422          { MUA, 0 | F_NOMATCH | F_PROPERTY, "\\X", "\xcc\x8d\xcc\x8d" },          { MUA, 0 | F_PROPERTY, "\\X", "\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+..", "\xcc\x8d#\xcc\x8d#\xcc\x8d\xcc\x8d" },          { MUA, 0 | F_PROPERTY, "\\X+..", "\xcc\x8d#\xcc\x8d#\xcc\x8d\xcc\x8d" },
425          { MUA, 0 | F_PROPERTY, "\\X{2,4}", "abcdef" },          { MUA, 0 | F_PROPERTY, "\\X{2,4}", "abcdef" },
# Line 566  static struct regression_test_case regre Line 573  static struct regression_test_case regre
573          { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)*l", "bc ddd abccabccl" },          { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)*l", "bc ddd abccabccl" },
574          { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+?dd", "bcabcacdb bdddd" },          { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+?dd", "bcabcacdb bdddd" },
575          { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+l", "ababccddabdbccd abcccl" },          { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+l", "ababccddabdbccd abcccl" },
576            { MUA, 0, "((?:a|aa)(?(1)aaa))x", "aax" },
577    
578          /* Set start of match. */          /* Set start of match. */
579          { MUA, 0, "(?:\\Ka)*aaaab", "aaaaaaaa aaaaaaabb" },          { MUA, 0, "(?:\\Ka)*aaaab", "aaaaaaaa aaaaaaabb" },
# Line 583  static struct regression_test_case regre Line 591  static struct regression_test_case regre
591          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "[abc]", "\na" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "[abc]", "\na" },
592          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^a", "\na" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^a", "\na" },
593          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^(?<=\n)", "\na" },          { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^(?<=\n)", "\na" },
594            { MUA | PCRE_FIRSTLINE, 0, "\xf0\x90\x90\x80", "\xf0\x90\x90\x80" },
595          { 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#" },
596          { PCRE_MULTILINE | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\x85#" },          { PCRE_MULTILINE | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\x85#" },
597          { 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 601  static struct regression_test_case regre
601          { 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" },
602          { 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" },
603          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 1, ".", "\r\n" },          { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 1, ".", "\r\n" },
604            { PCRE_FIRSTLINE | PCRE_NEWLINE_LF | PCRE_DOTALL, 0 | F_NOMATCH, "ab.", "ab" },
605    
606          /* Recurse. */          /* Recurse. */
607          { MUA, 0, "(a)(?1)", "aa" },          { MUA, 0, "(a)(?1)", "aa" },
# Line 674  static struct regression_test_case regre Line 684  static struct regression_test_case regre
684          { MUA, 0, "(?(DEFINE)(a(*:aa)))a(?1)b|aac", "aac" },          { MUA, 0, "(?(DEFINE)(a(*:aa)))a(?1)b|aac", "aac" },
685          { MUA, 0, "(a(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },          { MUA, 0, "(a(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },
686          { MUA, 0, "(a(*:aa)){0}(?:b(?1)b)+", "babba" },          { MUA, 0, "(a(*:aa)){0}(?:b(?1)b)+", "babba" },
687          { MUA, 0 | F_NOMATCH, "(a(*:aa)){0}(?:b(?1)b)+", "ba" },          { MUA, 0 | F_NOMATCH | F_STUDY, "(a(*:aa)){0}(?:b(?1)b)+", "ba" },
688          { MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },          { MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },
689          { MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b)+", "babba" },          { MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b)+", "babba" },
690          { MUA, 0 | F_NOMATCH, "(a\\K(*:aa)){0}(?:b(?1)b)+", "ba" },          { MUA, 0 | F_NOMATCH | F_STUDY, "(a\\K(*:aa)){0}(?:b(?1)b)+", "ba" },
691            { MUA, 0 | F_NOMATCH | F_STUDY, "(*:mark)m", "a" },
692    
693          /* (*COMMIT) verb. */          /* (*COMMIT) verb. */
694          { MUA, 0 | F_NOMATCH, "a(*COMMIT)b", "ac" },          { MUA, 0 | F_NOMATCH, "a(*COMMIT)b", "ac" },
# Line 709  static const unsigned char *tables(int m Line 720  static const unsigned char *tables(int m
720          const char *errorptr;          const char *errorptr;
721          int erroroffset;          int erroroffset;
722          unsigned char *default_tables;          unsigned char *default_tables;
723  #ifdef SUPPORT_PCRE8  #if defined SUPPORT_PCRE8
724          pcre *regex;          pcre *regex;
725          char null_str[1] = { 0 };          char null_str[1] = { 0 };
726  #else  #elif defined SUPPORT_PCRE16
727          pcre16 *regex;          pcre16 *regex;
728          PCRE_UCHAR16 null_str[1] = { 0 };          PCRE_UCHAR16 null_str[1] = { 0 };
729    #elif defined SUPPORT_PCRE32
730            pcre32 *regex;
731            PCRE_UCHAR32 null_str[1] = { 0 };
732  #endif  #endif
733    
734          if (mode) {          if (mode) {
# Line 728  static const unsigned char *tables(int m Line 742  static const unsigned char *tables(int m
742                  return tables_copy;                  return tables_copy;
743    
744          default_tables = NULL;          default_tables = NULL;
745  #ifdef SUPPORT_PCRE8  #if defined SUPPORT_PCRE8
746          regex = pcre_compile(null_str, 0, &errorptr, &erroroffset, NULL);          regex = pcre_compile(null_str, 0, &errorptr, &erroroffset, NULL);
747          if (regex) {          if (regex) {
748                  pcre_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);                  pcre_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
749                  pcre_free(regex);                  pcre_free(regex);
750          }          }
751  #else  #elif defined SUPPORT_PCRE16
752          regex = pcre16_compile(null_str, 0, &errorptr, &erroroffset, NULL);          regex = pcre16_compile(null_str, 0, &errorptr, &erroroffset, NULL);
753          if (regex) {          if (regex) {
754                  pcre16_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);                  pcre16_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
755                  pcre16_free(regex);                  pcre16_free(regex);
756          }          }
757    #elif defined SUPPORT_PCRE32
758            regex = pcre32_compile(null_str, 0, &errorptr, &erroroffset, NULL);
759            if (regex) {
760                    pcre32_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
761                    pcre32_free(regex);
762            }
763  #endif  #endif
764          /* Shouldn't ever happen. */          /* Shouldn't ever happen. */
765          if (!default_tables)          if (!default_tables)
# Line 769  static pcre16_jit_stack* callback16(void Line 789  static pcre16_jit_stack* callback16(void
789  }  }
790  #endif  #endif
791    
792    #ifdef SUPPORT_PCRE32
793    static pcre32_jit_stack* callback32(void *arg)
794    {
795            return (pcre32_jit_stack *)arg;
796    }
797    #endif
798    
799  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
800  static void setstack8(pcre_extra *extra)  static pcre_jit_stack *stack8;
801    
802    static pcre_jit_stack *getstack8(void)
803  {  {
804          static pcre_jit_stack *stack;          if (!stack8)
805                    stack8 = pcre_jit_stack_alloc(1, 1024 * 1024);
806            return stack8;
807    }
808    
809    static void setstack8(pcre_extra *extra)
810    {
811          if (!extra) {          if (!extra) {
812                  if (stack)                  if (stack8)
813                          pcre_jit_stack_free(stack);                          pcre_jit_stack_free(stack8);
814                  stack = NULL;                  stack8 = NULL;
815                  return;                  return;
816          }          }
817    
818          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);  
819  }  }
820  #endif /* SUPPORT_PCRE8 */  #endif /* SUPPORT_PCRE8 */
821    
822  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
823    static pcre16_jit_stack *stack16;
824    
825    static pcre16_jit_stack *getstack16(void)
826    {
827            if (!stack16)
828                    stack16 = pcre16_jit_stack_alloc(1, 1024 * 1024);
829            return stack16;
830    }
831    
832  static void setstack16(pcre16_extra *extra)  static void setstack16(pcre16_extra *extra)
833  {  {
834          static pcre16_jit_stack *stack;          if (!extra) {
835                    if (stack16)
836                            pcre16_jit_stack_free(stack16);
837                    stack16 = NULL;
838                    return;
839            }
840    
841            pcre16_assign_jit_stack(extra, callback16, getstack16());
842    }
843    #endif /* SUPPORT_PCRE8 */
844    
845    #ifdef SUPPORT_PCRE32
846    static pcre32_jit_stack *stack32;
847    
848    static pcre32_jit_stack *getstack32(void)
849    {
850            if (!stack32)
851                    stack32 = pcre32_jit_stack_alloc(1, 1024 * 1024);
852            return stack32;
853    }
854    
855    static void setstack32(pcre32_extra *extra)
856    {
857          if (!extra) {          if (!extra) {
858                  if (stack)                  if (stack32)
859                          pcre16_jit_stack_free(stack);                          pcre32_jit_stack_free(stack32);
860                  stack = NULL;                  stack32 = NULL;
861                  return;                  return;
862          }          }
863    
864          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);  
865  }  }
866  #endif /* SUPPORT_PCRE8 */  #endif /* SUPPORT_PCRE8 */
867    
# Line 812  static void setstack16(pcre16_extra *ext Line 870  static void setstack16(pcre16_extra *ext
870  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)
871  {  {
872          unsigned char *iptr = (unsigned char*)input;          unsigned char *iptr = (unsigned char*)input;
873          unsigned short *optr = (unsigned short *)output;          PCRE_UCHAR16 *optr = output;
874          unsigned int c;          unsigned int c;
875    
876          if (max_length == 0)          if (max_length == 0)
# Line 841  static int convert_utf8_to_utf16(const c Line 899  static int convert_utf8_to_utf16(const c
899                          max_length--;                          max_length--;
900                  } else if (max_length <= 2) {                  } else if (max_length <= 2) {
901                          *optr = '\0';                          *optr = '\0';
902                          return (int)(optr - (unsigned short *)output);                          return (int)(optr - output);
903                  } else {                  } else {
904                          c -= 0x10000;                          c -= 0x10000;
905                          *optr++ = 0xd800 | ((c >> 10) & 0x3ff);                          *optr++ = 0xd800 | ((c >> 10) & 0x3ff);
# Line 854  static int convert_utf8_to_utf16(const c Line 912  static int convert_utf8_to_utf16(const c
912          if (offsetmap)          if (offsetmap)
913                  *offsetmap = (int)(iptr - (unsigned char*)input);                  *offsetmap = (int)(iptr - (unsigned char*)input);
914          *optr = '\0';          *optr = '\0';
915          return (int)(optr - (unsigned short *)output);          return (int)(optr - output);
916  }  }
917    
918  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)
919  {  {
920          unsigned char *iptr = (unsigned char*)input;          unsigned char *iptr = (unsigned char*)input;
921          unsigned short *optr = (unsigned short *)output;          PCRE_UCHAR16 *optr = output;
922    
923          if (max_length == 0)          if (max_length == 0)
924                  return 0;                  return 0;
# Line 870  static int copy_char8_to_char16(const ch Line 928  static int copy_char8_to_char16(const ch
928                  max_length--;                  max_length--;
929          }          }
930          *optr = '\0';          *optr = '\0';
931          return (int)(optr - (unsigned short *)output);          return (int)(optr - output);
932  }  }
933    
934  #define REGTEST_MAX_LENGTH 4096  #define REGTEST_MAX_LENGTH16 4096
935  static PCRE_UCHAR16 regtest_buf[REGTEST_MAX_LENGTH];  static PCRE_UCHAR16 regtest_buf16[REGTEST_MAX_LENGTH16];
936  static int regtest_offsetmap[REGTEST_MAX_LENGTH];  static int regtest_offsetmap16[REGTEST_MAX_LENGTH16];
937    
938  #endif /* SUPPORT_PCRE16 */  #endif /* SUPPORT_PCRE16 */
939    
940    #ifdef SUPPORT_PCRE32
941    
942    static int convert_utf8_to_utf32(const char *input, PCRE_UCHAR32 *output, int *offsetmap, int max_length)
943    {
944            unsigned char *iptr = (unsigned char*)input;
945            PCRE_UCHAR32 *optr = output;
946            unsigned int c;
947    
948            if (max_length == 0)
949                    return 0;
950    
951            while (*iptr && max_length > 1) {
952                    c = 0;
953                    if (offsetmap)
954                            *offsetmap++ = (int)(iptr - (unsigned char*)input);
955    
956                    if (!(*iptr & 0x80))
957                            c = *iptr++;
958                    else if (!(*iptr & 0x20)) {
959                            c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
960                            iptr += 2;
961                    } else if (!(*iptr & 0x10)) {
962                            c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
963                            iptr += 3;
964                    } else if (!(*iptr & 0x08)) {
965                            c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
966                            iptr += 4;
967                    }
968    
969                    *optr++ = c;
970                    max_length--;
971            }
972            if (offsetmap)
973                    *offsetmap = (int)(iptr - (unsigned char*)input);
974            *optr = 0;
975            return (int)(optr - output);
976    }
977    
978    static int copy_char8_to_char32(const char *input, PCRE_UCHAR32 *output, int max_length)
979    {
980            unsigned char *iptr = (unsigned char*)input;
981            PCRE_UCHAR32 *optr = output;
982    
983            if (max_length == 0)
984                    return 0;
985    
986            while (*iptr && max_length > 1) {
987                    *optr++ = *iptr++;
988                    max_length--;
989            }
990            *optr = '\0';
991            return (int)(optr - output);
992    }
993    
994    #define REGTEST_MAX_LENGTH32 4096
995    static PCRE_UCHAR32 regtest_buf32[REGTEST_MAX_LENGTH32];
996    static int regtest_offsetmap32[REGTEST_MAX_LENGTH32];
997    
998    #endif /* SUPPORT_PCRE32 */
999    
1000  static int check_ascii(const char *input)  static int check_ascii(const char *input)
1001  {  {
1002          const unsigned char *ptr = (unsigned char *)input;          const unsigned char *ptr = (unsigned char *)input;
# Line 902  static int regression_tests(void) Line 1020  static int regression_tests(void)
1020          int successful_row = 0;          int successful_row = 0;
1021          int counter = 0;          int counter = 0;
1022          int study_mode;          int study_mode;
1023            int utf = 0, ucp = 0;
1024            int disabled_flags = 0;
1025  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1026          pcre *re8;          pcre *re8;
1027          pcre_extra *extra8;          pcre_extra *extra8;
1028          pcre_extra dummy_extra8;          pcre_extra dummy_extra8;
1029          int ovector8_1[32];          int ovector8_1[32];
1030          int ovector8_2[32];          int ovector8_2[32];
1031          int return_value8_1, return_value8_2;          int return_value8[2];
1032          unsigned char *mark8_1, *mark8_2;          unsigned char *mark8_1, *mark8_2;
         int utf8 = 0, ucp8 = 0;  
         int disabled_flags8 = 0;  
1033  #endif  #endif
1034  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1035          pcre16 *re16;          pcre16 *re16;
# Line 919  static int regression_tests(void) Line 1037  static int regression_tests(void)
1037          pcre16_extra dummy_extra16;          pcre16_extra dummy_extra16;
1038          int ovector16_1[32];          int ovector16_1[32];
1039          int ovector16_2[32];          int ovector16_2[32];
1040          int return_value16_1, return_value16_2;          int return_value16[2];
1041          PCRE_UCHAR16 *mark16_1, *mark16_2;          PCRE_UCHAR16 *mark16_1, *mark16_2;
         int utf16 = 0, ucp16 = 0;  
         int disabled_flags16 = 0;  
1042          int length16;          int length16;
1043  #endif  #endif
1044    #ifdef SUPPORT_PCRE32
1045            pcre32 *re32;
1046            pcre32_extra *extra32;
1047            pcre32_extra dummy_extra32;
1048            int ovector32_1[32];
1049            int ovector32_2[32];
1050            int return_value32[2];
1051            PCRE_UCHAR32 *mark32_1, *mark32_2;
1052            int length32;
1053    #endif
1054    
1055          /* This test compares the behaviour of interpreter and JIT. Although disabling          /* This test compares the behaviour of interpreter and JIT. Although disabling
1056          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
1057          still considered successful from pcre_jit_test point of view. */          still considered successful from pcre_jit_test point of view. */
1058    
1059  #ifdef SUPPORT_PCRE8  #if defined SUPPORT_PCRE8
1060          pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);          pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1061  #else  #elif defined SUPPORT_PCRE16
1062          pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);          pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1063    #elif defined SUPPORT_PCRE32
1064            pcre32_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1065  #endif  #endif
1066    
1067          printf("Running JIT regression tests\n");          printf("Running JIT regression tests\n");
1068          printf("  target CPU of SLJIT compiler: %s\n", cpu_info);          printf("  target CPU of SLJIT compiler: %s\n", cpu_info);
1069    
1070    #if defined SUPPORT_PCRE8
1071            pcre_config(PCRE_CONFIG_UTF8, &utf);
1072            pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1073    #elif defined SUPPORT_PCRE16
1074            pcre16_config(PCRE_CONFIG_UTF16, &utf);
1075            pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1076    #elif defined SUPPORT_PCRE16
1077            pcre32_config(PCRE_CONFIG_UTF32, &utf);
1078            pcre32_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1079    #endif
1080    
1081            if (!utf)
1082                    disabled_flags |= PCRE_UTF8 | PCRE_UTF16 | PCRE_UTF32;
1083            if (!ucp)
1084                    disabled_flags |= PCRE_UCP;
1085  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1086          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");  
1087  #endif  #endif
1088  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1089          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");
1090          pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp16);  #endif
1091          if (!utf16)  #ifdef SUPPORT_PCRE32
1092                  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");  
1093  #endif  #endif
1094    
1095          while (current->pattern) {          while (current->pattern) {
# Line 980  static int regression_tests(void) Line 1114  static int regression_tests(void)
1114                  re8 = NULL;                  re8 = NULL;
1115                  if (!(current->start_offset & F_NO8))                  if (!(current->start_offset & F_NO8))
1116                          re8 = pcre_compile(current->pattern,                          re8 = pcre_compile(current->pattern,
1117                                  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),
1118                                  &error, &err_offs, tables(0));                                  &error, &err_offs, tables(0));
1119    
1120                  extra8 = NULL;                  extra8 = NULL;
# Line 992  static int regression_tests(void) Line 1126  static int regression_tests(void)
1126                                  pcre_free(re8);                                  pcre_free(re8);
1127                                  re8 = NULL;                                  re8 = NULL;
1128                          }                          }
1129                          if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {                          else if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1130                                  printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);                                  printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);
1131                                  pcre_free_study(extra8);                                  pcre_free_study(extra8);
1132                                  pcre_free(re8);                                  pcre_free(re8);
1133                                  re8 = NULL;                                  re8 = NULL;
1134                          }                          }
1135                          extra8->flags |= PCRE_EXTRA_MARK;                          extra8->flags |= PCRE_EXTRA_MARK;
1136                  } else if (((utf8 && ucp8) || is_ascii_pattern) && !(current->start_offset & F_NO8))                  } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO8))
1137                          printf("\n8 bit: Cannot compile pattern: %s\n", current->pattern);                          printf("\n8 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1138  #endif  #endif
1139  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1140                  if ((current->flags & PCRE_UTF8) || (current->start_offset & F_FORCECONV))                  if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
1141                          convert_utf8_to_utf16(current->pattern, regtest_buf, NULL, REGTEST_MAX_LENGTH);                          convert_utf8_to_utf16(current->pattern, regtest_buf16, NULL, REGTEST_MAX_LENGTH16);
1142                  else                  else
1143                          copy_char8_to_char16(current->pattern, regtest_buf, REGTEST_MAX_LENGTH);                          copy_char8_to_char16(current->pattern, regtest_buf16, REGTEST_MAX_LENGTH16);
1144    
1145                  re16 = NULL;                  re16 = NULL;
1146                  if (!(current->start_offset & F_NO16))                  if (!(current->start_offset & F_NO16))
1147                          re16 = pcre16_compile(regtest_buf,                          re16 = pcre16_compile(regtest_buf16,
1148                                  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),
1149                                  &error, &err_offs, tables(0));                                  &error, &err_offs, tables(0));
1150    
1151                  extra16 = NULL;                  extra16 = NULL;
# Line 1023  static int regression_tests(void) Line 1157  static int regression_tests(void)
1157                                  pcre16_free(re16);                                  pcre16_free(re16);
1158                                  re16 = NULL;                                  re16 = NULL;
1159                          }                          }
1160                          if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {                          else if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1161                                  printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);                                  printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);
1162                                  pcre16_free_study(extra16);                                  pcre16_free_study(extra16);
1163                                  pcre16_free(re16);                                  pcre16_free(re16);
1164                                  re16 = NULL;                                  re16 = NULL;
1165                          }                          }
1166                          extra16->flags |= PCRE_EXTRA_MARK;                          extra16->flags |= PCRE_EXTRA_MARK;
1167                  } else if (((utf16 && ucp16) || is_ascii_pattern) && !(current->start_offset & F_NO16))                  } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO16))
1168                          printf("\n16 bit: Cannot compile pattern: %s\n", current->pattern);                          printf("\n16 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1169    #endif
1170    #ifdef SUPPORT_PCRE32
1171                    if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
1172                            convert_utf8_to_utf32(current->pattern, regtest_buf32, NULL, REGTEST_MAX_LENGTH32);
1173                    else
1174                            copy_char8_to_char32(current->pattern, regtest_buf32, REGTEST_MAX_LENGTH32);
1175    
1176                    re32 = NULL;
1177                    if (!(current->start_offset & F_NO32))
1178                            re32 = pcre32_compile(regtest_buf32,
1179                                    current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
1180                                    &error, &err_offs, tables(0));
1181    
1182                    extra32 = NULL;
1183                    if (re32) {
1184                            error = NULL;
1185                            extra32 = pcre32_study(re32, study_mode, &error);
1186                            if (!extra32) {
1187                                    printf("\n32 bit: Cannot study pattern: %s\n", current->pattern);
1188                                    pcre32_free(re32);
1189                                    re32 = NULL;
1190                            }
1191                            if (!(extra32->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1192                                    printf("\n32 bit: JIT compiler does not support: %s\n", current->pattern);
1193                                    pcre32_free_study(extra32);
1194                                    pcre32_free(re32);
1195                                    re32 = NULL;
1196                            }
1197                            extra32->flags |= PCRE_EXTRA_MARK;
1198                    } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO32))
1199                            printf("\n32 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1200  #endif  #endif
1201    
1202                  counter++;                  counter++;
# Line 1042  static int regression_tests(void) Line 1207  static int regression_tests(void)
1207  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1208                          setstack16(NULL);                          setstack16(NULL);
1209  #endif  #endif
1210    #ifdef SUPPORT_PCRE32
1211                            setstack32(NULL);
1212    #endif
1213                  }                  }
1214    
1215  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1216                  return_value8_1 = -1000;                  return_value8[0] = -1000;
1217                  return_value8_2 = -1000;                  return_value8[1] = -1000;
1218                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
1219                          ovector8_1[i] = -2;                          ovector8_1[i] = -2;
1220                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
# Line 1054  static int regression_tests(void) Line 1222  static int regression_tests(void)
1222                  if (re8) {                  if (re8) {
1223                          mark8_1 = NULL;                          mark8_1 = NULL;
1224                          mark8_2 = NULL;                          mark8_2 = NULL;
                         setstack8(extra8);  
1225                          extra8->mark = &mark8_1;                          extra8->mark = &mark8_1;
1226                          return_value8_1 = 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);                          if ((counter & 0x1) != 0) {
1228                                    setstack8(extra8);
1229                                    return_value8[0] = pcre_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);
1231                            } else
1232                                    return_value8[0] = pcre_jit_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1233                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32, getstack8());
1234                          memset(&dummy_extra8, 0, sizeof(pcre_extra));                          memset(&dummy_extra8, 0, sizeof(pcre_extra));
1235                          dummy_extra8.flags = PCRE_EXTRA_MARK;                          dummy_extra8.flags = PCRE_EXTRA_MARK;
1236                            if (current->start_offset & F_STUDY) {
1237                                    dummy_extra8.flags |= PCRE_EXTRA_STUDY_DATA;
1238                                    dummy_extra8.study_data = extra8->study_data;
1239                            }
1240                          dummy_extra8.mark = &mark8_2;                          dummy_extra8.mark = &mark8_2;
1241                          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,
1242                                  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);
1243                  }                  }
1244  #endif  #endif
1245    
1246  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1247                  return_value16_1 = -1000;                  return_value16[0] = -1000;
1248                  return_value16_2 = -1000;                  return_value16[1] = -1000;
1249                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
1250                          ovector16_1[i] = -2;                          ovector16_1[i] = -2;
1251                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
# Line 1076  static int regression_tests(void) Line 1253  static int regression_tests(void)
1253                  if (re16) {                  if (re16) {
1254                          mark16_1 = NULL;                          mark16_1 = NULL;
1255                          mark16_2 = NULL;                          mark16_2 = NULL;
1256                          setstack16(extra16);                          if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
1257                          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);  
1258                          else                          else
1259                                  length16 = copy_char8_to_char16(current->input, regtest_buf, REGTEST_MAX_LENGTH);                                  length16 = copy_char8_to_char16(current->input, regtest_buf16, REGTEST_MAX_LENGTH16);
1260                          extra16->mark = &mark16_1;                          extra16->mark = &mark16_1;
1261                          return_value16_1 = pcre16_exec(re16, extra16, regtest_buf, length16, current->start_offset & OFFSET_MASK,                          if ((counter & 0x1) != 0) {
1262                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32);                                  setstack16(extra16);
1263                                    return_value16[0] = pcre16_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1264                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32);
1265                            } else
1266                                    return_value16[0] = pcre16_jit_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1267                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32, getstack16());
1268                          memset(&dummy_extra16, 0, sizeof(pcre16_extra));                          memset(&dummy_extra16, 0, sizeof(pcre16_extra));
1269                          dummy_extra16.flags = PCRE_EXTRA_MARK;                          dummy_extra16.flags = PCRE_EXTRA_MARK;
1270                            if (current->start_offset & F_STUDY) {
1271                                    dummy_extra16.flags |= PCRE_EXTRA_STUDY_DATA;
1272                                    dummy_extra16.study_data = extra16->study_data;
1273                            }
1274                          dummy_extra16.mark = &mark16_2;                          dummy_extra16.mark = &mark16_2;
1275                          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,
1276                                  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);
1277                  }                  }
1278  #endif  #endif
1279    
1280                  /* 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
1281                    return_value32[0] = -1000;
1282                    return_value32[1] = -1000;
1283                    for (i = 0; i < 32; ++i)
1284                            ovector32_1[i] = -2;
1285                    for (i = 0; i < 32; ++i)
1286                            ovector32_2[i] = -2;
1287                    if (re32) {
1288                            mark32_1 = NULL;
1289                            mark32_2 = NULL;
1290                            if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
1291                                    length32 = convert_utf8_to_utf32(current->input, regtest_buf32, regtest_offsetmap32, REGTEST_MAX_LENGTH32);
1292                            else
1293                                    length32 = copy_char8_to_char32(current->input, regtest_buf32, REGTEST_MAX_LENGTH32);
1294                            extra32->mark = &mark32_1;
1295                            if ((counter & 0x1) != 0) {
1296                                    setstack32(extra32);
1297                                    return_value32[0] = pcre32_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1298                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_1, 32);
1299                            } else
1300                                    return_value32[0] = pcre32_jit_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1301                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_1, 32, getstack32());
1302                            memset(&dummy_extra32, 0, sizeof(pcre32_extra));
1303                            dummy_extra32.flags = PCRE_EXTRA_MARK;
1304                            if (current->start_offset & F_STUDY) {
1305                                    dummy_extra32.flags |= PCRE_EXTRA_STUDY_DATA;
1306                                    dummy_extra32.study_data = extra32->study_data;
1307                            }
1308                            dummy_extra32.mark = &mark32_2;
1309                            return_value32[1] = pcre32_exec(re32, &dummy_extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1310                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_2, 32);
1311                    }
1312    #endif
1313    
1314                    /* printf("[%d-%d-%d|%d-%d|%d-%d|%d-%d]%s",
1315                            return_value8[0], return_value16[0],
1316                            ovector8_1[0], ovector8_1[1],
1317                            ovector16_1[0], ovector16_1[1],
1318                            ovector32_1[0], ovector32_1[1],
1319                            (current->flags & PCRE_CASELESS) ? "C" : ""); */
1320    
1321                  /* 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.
1322                  Segfaults can still be captured. */                  Segfaults can still be captured. */
1323    
1324                  is_successful = 1;                  is_successful = 1;
1325                  if (!(current->start_offset & F_DIFF)) {                  if (!(current->start_offset & F_DIFF)) {
1326  #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16  #if defined SUPPORT_UTF && ((defined(SUPPORT_PCRE8) + defined(SUPPORT_PCRE16) + defined(SUPPORT_PCRE32)) >= 2)
1327                          if (utf8 == utf16 && !(current->start_offset & F_FORCECONV)) {                          if (!(current->start_offset & F_FORCECONV)) {
1328                                    int return_value;
1329    
1330                                  /* All results must be the same. */                                  /* All results must be the same. */
1331                                  if (return_value8_1 != return_value8_2 || return_value8_1 != return_value16_1 || return_value8_1 != return_value16_2) {  #ifdef SUPPORT_PCRE8
1332                                          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]) {
1333                                                  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",
1334                                                    return_value8[0], return_value8[1], total, current->pattern, current->input);
1335                                            is_successful = 0;
1336                                    } else
1337    #endif
1338    #ifdef SUPPORT_PCRE16
1339                                    if ((return_value = return_value16[0]) != return_value16[1]) {
1340                                            printf("\n16 bit: Return value differs(J16:%d,I16:%d): [%d] '%s' @ '%s'\n",
1341                                                    return_value16[0], return_value16[1], total, current->pattern, current->input);
1342                                            is_successful = 0;
1343                                    } else
1344    #endif
1345    #ifdef SUPPORT_PCRE32
1346                                    if ((return_value = return_value32[0]) != return_value32[1]) {
1347                                            printf("\n32 bit: Return value differs(J32:%d,I32:%d): [%d] '%s' @ '%s'\n",
1348                                                    return_value32[0], return_value32[1], total, current->pattern, current->input);
1349                                            is_successful = 0;
1350                                    } else
1351    #endif
1352    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
1353                                    if (return_value8[0] != return_value16[0]) {
1354                                            printf("\n8 and 16 bit: Return value differs(J8:%d,J16:%d): [%d] '%s' @ '%s'\n",
1355                                                    return_value8[0], return_value16[0],
1356                                                    total, current->pattern, current->input);
1357                                            is_successful = 0;
1358                                    } else
1359    #endif
1360    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
1361                                    if (return_value8[0] != return_value32[0]) {
1362                                            printf("\n8 and 32 bit: Return value differs(J8:%d,J32:%d): [%d] '%s' @ '%s'\n",
1363                                                    return_value8[0], return_value32[0],
1364                                                    total, current->pattern, current->input);
1365                                            is_successful = 0;
1366                                    } else
1367    #endif
1368    #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE32
1369                                    if (return_value16[0] != return_value32[0]) {
1370                                            printf("\n16 and 32 bit: Return value differs(J16:%d,J32:%d): [%d] '%s' @ '%s'\n",
1371                                                    return_value16[0], return_value32[0],
1372                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1373                                          is_successful = 0;                                          is_successful = 0;
1374                                  } else if (return_value8_1 >= 0 || return_value8_1 == PCRE_ERROR_PARTIAL) {                                  } else
1375                                          if (return_value8_1 == PCRE_ERROR_PARTIAL) {  #endif
1376                                                  return_value8_1 = 2;                                  if (return_value >= 0 || return_value == PCRE_ERROR_PARTIAL) {
1377                                                  return_value16_1 = 2;                                          if (return_value == PCRE_ERROR_PARTIAL) {
1378                                                    return_value = 2;
1379                                          } else {                                          } else {
1380                                                  return_value8_1 *= 2;                                                  return_value *= 2;
                                                 return_value16_1 *= 2;  
1381                                          }                                          }
1382    #ifdef SUPPORT_PCRE8
1383                                            return_value8[0] = return_value;
1384    #endif
1385    #ifdef SUPPORT_PCRE16
1386                                            return_value16[0] = return_value;
1387    #endif
1388    #ifdef SUPPORT_PCRE32
1389                                            return_value32[0] = return_value;
1390    #endif
1391                                          /* Transform back the results. */                                          /* Transform back the results. */
1392                                          if (current->flags & PCRE_UTF8) {                                          if (current->flags & PCRE_UTF8) {
1393                                                  for (i = 0; i < return_value8_1; ++i) {  #ifdef SUPPORT_PCRE16
1394                                                    for (i = 0; i < return_value; ++i) {
1395                                                          if (ovector16_1[i] >= 0)                                                          if (ovector16_1[i] >= 0)
1396                                                                  ovector16_1[i] = regtest_offsetmap[ovector16_1[i]];                                                                  ovector16_1[i] = regtest_offsetmap16[ovector16_1[i]];
1397                                                          if (ovector16_2[i] >= 0)                                                          if (ovector16_2[i] >= 0)
1398                                                                  ovector16_2[i] = regtest_offsetmap[ovector16_2[i]];                                                                  ovector16_2[i] = regtest_offsetmap16[ovector16_2[i]];
1399                                                  }                                                  }
1400    #endif
1401    #ifdef SUPPORT_PCRE32
1402                                                    for (i = 0; i < return_value; ++i) {
1403                                                            if (ovector32_1[i] >= 0)
1404                                                                    ovector32_1[i] = regtest_offsetmap32[ovector32_1[i]];
1405                                                            if (ovector32_2[i] >= 0)
1406                                                                    ovector32_2[i] = regtest_offsetmap32[ovector32_2[i]];
1407                                                    }
1408    #endif
1409                                          }                                          }
1410    
1411                                          for (i = 0; i < return_value8_1; ++i)                                          for (i = 0; i < return_value; ++i) {
1412    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
1413                                                  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]) {
1414                                                          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",
1415                                                                  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],
1416                                                                  total, current->pattern, current->input);                                                                  total, current->pattern, current->input);
1417                                                          is_successful = 0;                                                          is_successful = 0;
1418                                                  }                                                  }
1419    #endif
1420    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
1421                                                    if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector32_1[i] || ovector8_1[i] != ovector32_2[i]) {
1422                                                            printf("\n8 and 32 bit: Ovector[%d] value differs(J8:%d,I8:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
1423                                                                    i, ovector8_1[i], ovector8_2[i], ovector32_1[i], ovector32_2[i],
1424                                                                    total, current->pattern, current->input);
1425                                                            is_successful = 0;
1426                                                    }
1427    #endif
1428    #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE16
1429                                                    if (ovector16_1[i] != ovector16_2[i] || ovector16_1[i] != ovector16_1[i] || ovector16_1[i] != ovector16_2[i]) {
1430                                                            printf("\n16 and 16 bit: Ovector[%d] value differs(J16:%d,I16:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
1431                                                                    i, ovector16_1[i], ovector16_2[i], ovector16_1[i], ovector16_2[i],
1432                                                                    total, current->pattern, current->input);
1433                                                            is_successful = 0;
1434                                                    }
1435    #endif
1436                                            }
1437                                  }                                  }
1438                          } else {                          } else
1439  #endif /* SUPPORT_PCRE8 && SUPPORT_PCRE16 */  #endif /* more than one of SUPPORT_PCRE8, SUPPORT_PCRE16 and SUPPORT_PCRE32 */
1440                            {
1441                                  /* Only the 8 bit and 16 bit results must be equal. */                                  /* Only the 8 bit and 16 bit results must be equal. */
1442  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1443                                  if (return_value8_1 != return_value8_2) {                                  if (return_value8[0] != return_value8[1]) {
1444                                          printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",                                          printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1445                                                  return_value8_1, return_value8_2, total, current->pattern, current->input);                                                  return_value8[0], return_value8[1], total, current->pattern, current->input);
1446                                          is_successful = 0;                                          is_successful = 0;
1447                                  } else if (return_value8_1 >= 0 || return_value8_1 == PCRE_ERROR_PARTIAL) {                                  } else if (return_value8[0] >= 0 || return_value8[0] == PCRE_ERROR_PARTIAL) {
1448                                          if (return_value8_1 == PCRE_ERROR_PARTIAL)                                          if (return_value8[0] == PCRE_ERROR_PARTIAL)
1449                                                  return_value8_1 = 2;                                                  return_value8[0] = 2;
1450                                          else                                          else
1451                                                  return_value8_1 *= 2;                                                  return_value8[0] *= 2;
1452    
1453                                          for (i = 0; i < return_value8_1; ++i)                                          for (i = 0; i < return_value8[0]; ++i)
1454                                                  if (ovector8_1[i] != ovector8_2[i]) {                                                  if (ovector8_1[i] != ovector8_2[i]) {
1455                                                          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",
1456                                                                  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 1460  static int regression_tests(void)
1460  #endif  #endif
1461    
1462  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1463                                  if (return_value16_1 != return_value16_2) {                                  if (return_value16[0] != return_value16[1]) {
1464                                          printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",                                          printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1465                                                  return_value16_1, return_value16_2, total, current->pattern, current->input);                                                  return_value16[0], return_value16[1], total, current->pattern, current->input);
1466                                          is_successful = 0;                                          is_successful = 0;
1467                                  } else if (return_value16_1 >= 0 || return_value16_1 == PCRE_ERROR_PARTIAL) {                                  } else if (return_value16[0] >= 0 || return_value16[0] == PCRE_ERROR_PARTIAL) {
1468                                          if (return_value16_1 == PCRE_ERROR_PARTIAL)                                          if (return_value16[0] == PCRE_ERROR_PARTIAL)
1469                                                  return_value16_1 = 2;                                                  return_value16[0] = 2;
1470                                          else                                          else
1471                                                  return_value16_1 *= 2;                                                  return_value16[0] *= 2;
1472    
1473                                          for (i = 0; i < return_value16_1; ++i)                                          for (i = 0; i < return_value16[0]; ++i)
1474                                                  if (ovector16_1[i] != ovector16_2[i]) {                                                  if (ovector16_1[i] != ovector16_2[i]) {
1475                                                          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",
1476                                                                  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 1479  static int regression_tests(void)
1479                                  }                                  }
1480  #endif  #endif
1481    
1482  #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16  #ifdef SUPPORT_PCRE32
1483                                    if (return_value32[0] != return_value32[1]) {
1484                                            printf("\n32 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1485                                                    return_value32[0], return_value32[1], total, current->pattern, current->input);
1486                                            is_successful = 0;
1487                                    } else if (return_value32[0] >= 0 || return_value32[0] == PCRE_ERROR_PARTIAL) {
1488                                            if (return_value32[0] == PCRE_ERROR_PARTIAL)
1489                                                    return_value32[0] = 2;
1490                                            else
1491                                                    return_value32[0] *= 2;
1492    
1493                                            for (i = 0; i < return_value32[0]; ++i)
1494                                                    if (ovector32_1[i] != ovector32_2[i]) {
1495                                                            printf("\n32 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
1496                                                                    i, ovector32_1[i], ovector32_2[i], total, current->pattern, current->input);
1497                                                            is_successful = 0;
1498                                                    }
1499                                    }
1500    #endif
1501                          }                          }
 #endif /* SUPPORT_PCRE8 && SUPPORT_PCRE16 */  
1502                  }                  }
1503    
1504                  if (is_successful) {                  if (is_successful) {
1505  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1506                          if (!(current->start_offset & F_NO8) && ((utf8 && ucp8) || is_ascii_input)) {                          if (!(current->start_offset & F_NO8) && ((utf && ucp) || is_ascii_input)) {
1507                                  if (return_value8_1 < 0 && !(current->start_offset & F_NOMATCH)) {                                  if (return_value8[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1508                                          printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",                                          printf("8 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_value8_1 >= 0 && (current->start_offset & F_NOMATCH)) {                                  if (return_value8[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1514                                          printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",                                          printf("8 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;
# Line 1199  static int regression_tests(void) Line 1518  static int regression_tests(void)
1518                          }                          }
1519  #endif  #endif
1520  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1521                          if (!(current->start_offset & F_NO16) && ((utf16 && ucp16) || is_ascii_input)) {                          if (!(current->start_offset & F_NO16) && ((utf && ucp) || is_ascii_input)) {
1522                                  if (return_value16_1 < 0 && !(current->start_offset & F_NOMATCH)) {                                  if (return_value16[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1523                                          printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",                                          printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",
1524                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1525                                          is_successful = 0;                                          is_successful = 0;
1526                                  }                                  }
1527    
1528                                  if (return_value16_1 >= 0 && (current->start_offset & F_NOMATCH)) {                                  if (return_value16[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1529                                          printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",                                          printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",
1530                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1531                                          is_successful = 0;                                          is_successful = 0;
1532                                  }                                  }
1533                          }                          }
1534  #endif  #endif
1535    #ifdef SUPPORT_PCRE32
1536                            if (!(current->start_offset & F_NO32) && ((utf && ucp) || is_ascii_input)) {
1537                                    if (return_value32[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1538                                            printf("32 bit: Test should match: [%d] '%s' @ '%s'\n",
1539                                                    total, current->pattern, current->input);
1540                                            is_successful = 0;
1541                                    }
1542    
1543                                    if (return_value32[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1544                                            printf("32 bit: Test should not match: [%d] '%s' @ '%s'\n",
1545                                                    total, current->pattern, current->input);
1546                                            is_successful = 0;
1547                                    }
1548                            }
1549    #endif
1550                  }                  }
1551    
1552                  if (is_successful) {                  if (is_successful) {
# Line 1230  static int regression_tests(void) Line 1564  static int regression_tests(void)
1564                                  is_successful = 0;                                  is_successful = 0;
1565                          }                          }
1566  #endif  #endif
1567    #ifdef SUPPORT_PCRE32
1568                            if (mark32_1 != mark32_2) {
1569                                    printf("32 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1570                                            total, current->pattern, current->input);
1571                                    is_successful = 0;
1572                            }
1573    #endif
1574                  }                  }
1575    
1576  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
# Line 1244  static int regression_tests(void) Line 1585  static int regression_tests(void)
1585                          pcre16_free(re16);                          pcre16_free(re16);
1586                  }                  }
1587  #endif  #endif
1588    #ifdef SUPPORT_PCRE32
1589                    if (re32) {
1590                            pcre32_free_study(extra32);
1591                            pcre32_free(re32);
1592                    }
1593    #endif
1594    
1595                  if (is_successful) {                  if (is_successful) {
1596                          successful++;                          successful++;
# Line 1266  static int regression_tests(void) Line 1613  static int regression_tests(void)
1613  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1614          setstack16(NULL);          setstack16(NULL);
1615  #endif  #endif
1616    #ifdef SUPPORT_PCRE32
1617            setstack32(NULL);
1618    #endif
1619    
1620          if (total == successful) {          if (total == successful) {
1621                  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.1245

  ViewVC Help
Powered by ViewVC 1.1.5