/[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 1282 by zherczeg, Fri Mar 15 08:01:41 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 685  static struct regression_test_case regre Line 696  static struct regression_test_case regre
696          { MUA, 0 | F_NOMATCH, "a(*COMMIT)(*:msg)b|ac", "ac" },          { MUA, 0 | F_NOMATCH, "a(*COMMIT)(*:msg)b|ac", "ac" },
697          { MUA, 0, "(?=a(*COMMIT)b|ac)ac|(*:m)(a)c", "ac" },          { MUA, 0, "(?=a(*COMMIT)b|ac)ac|(*:m)(a)c", "ac" },
698          { MUA, 0, "(?!a(*COMMIT)(*:msg)b)a(c)|cd", "acd" },          { MUA, 0, "(?!a(*COMMIT)(*:msg)b)a(c)|cd", "acd" },
699            { MUA, 0, "(?=(a)(*COMMIT)b)|ac", "ac" },
700            { MUA, 0, "(?=(a)+(*COMMIT)b)|ac", "ac" },
701            { MUA, 0 | F_NOMATCH, "(a(*COMMIT)b)++", "abac" },
702            { MUA, 0 | F_NOMATCH, "((a)(*COMMIT)b)++", "abac" },
703    
704            /* (*PRUNE) verb. */
705            { MUA, 0, "aa\\K(*PRUNE)b", "aaab" },
706            { MUA, 0, "aa(*PRUNE:bb)b|a", "aa" },
707            { MUA, 0, "(a)(a)(*PRUNE)b|(a)", "aa" },
708            { MUA, 0, "(a)(a)(a)(a)(a)(a)(a)(a)(*PRUNE)b|(a)", "aaaaaaaa" },
709            { MUA | PCRE_PARTIAL_SOFT, 0, "a(*PRUNE)a|", "a" },
710            { MUA | PCRE_PARTIAL_SOFT, 0, "a(*PRUNE)a|m", "a" },
711            { MUA, 0 | F_NOMATCH, "a(*COMMIT)(*PRUNE)d|bc", "abc" },
712            { MUA, 0, "(?=a(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
713            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?=a(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
714            { MUA, 0, "(?=(a)(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
715            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?=(a)(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
716            { MUA, 0, "(a(*COMMIT)b){0}a(?1)(*PRUNE)c|bc", "abc" },
717            { MUA, 0 | F_NOMATCH, "(a(*COMMIT)b){0}a(*COMMIT)(?1)(*PRUNE)c|bc", "abc" },
718            { MUA, 0, "(a(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
719            { MUA, 0 | F_NOMATCH, "(*COMMIT)(a(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
720            { MUA, 0, "((a)(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
721            { MUA, 0 | F_NOMATCH, "(*COMMIT)((a)(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
722            { MUA, 0, "(?>a(*COMMIT)b)*abab(*PRUNE)d|ba", "ababab" },
723            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)*abab(*PRUNE)d|ba", "ababab" },
724            { MUA, 0, "(?>a(*COMMIT)b)+abab(*PRUNE)d|ba", "ababab" },
725            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)+abab(*PRUNE)d|ba", "ababab" },
726            { MUA, 0, "(?>a(*COMMIT)b)?ab(*PRUNE)d|ba", "aba" },
727            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)?ab(*PRUNE)d|ba", "aba" },
728            { MUA, 0, "(?>a(*COMMIT)b)*?n(*PRUNE)d|ba", "abababn" },
729            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)*?n(*PRUNE)d|ba", "abababn" },
730            { MUA, 0, "(?>a(*COMMIT)b)+?n(*PRUNE)d|ba", "abababn" },
731            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)+?n(*PRUNE)d|ba", "abababn" },
732            { MUA, 0, "(?>a(*COMMIT)b)??n(*PRUNE)d|bn", "abn" },
733            { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)??n(*PRUNE)d|bn", "abn" },
734    
735            /* (*THEN) verb. */
736            { MUA, 0, "((?:a(*THEN)|aab)(*THEN)c|a+)+m", "aabcaabcaabcaabcnacm" },
737            { MUA, 0 | F_NOMATCH, "((?:a(*THEN)|aab)(*THEN)c|a+)+m", "aabcm" },
738            { MUA, 0, "((?:a(*THEN)|aab)c|a+)+m", "aabcaabcnmaabcaabcm" },
739            { MUA, 0, "((?:a|aab)(*THEN)c|a+)+m", "aam" },
740            { MUA, 0 | F_NOMATCH, "((?:a(*COMMIT)|aab)(*THEN)c|a+)+m", "aam" },
741    
742          /* Deep recursion. */          /* Deep recursion. */
743          { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },          { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },
# Line 709  static const unsigned char *tables(int m Line 762  static const unsigned char *tables(int m
762          const char *errorptr;          const char *errorptr;
763          int erroroffset;          int erroroffset;
764          unsigned char *default_tables;          unsigned char *default_tables;
765  #ifdef SUPPORT_PCRE8  #if defined SUPPORT_PCRE8
766          pcre *regex;          pcre *regex;
767          char null_str[1] = { 0 };          char null_str[1] = { 0 };
768  #else  #elif defined SUPPORT_PCRE16
769          pcre16 *regex;          pcre16 *regex;
770          PCRE_UCHAR16 null_str[1] = { 0 };          PCRE_UCHAR16 null_str[1] = { 0 };
771    #elif defined SUPPORT_PCRE32
772            pcre32 *regex;
773            PCRE_UCHAR32 null_str[1] = { 0 };
774  #endif  #endif
775    
776          if (mode) {          if (mode) {
# Line 728  static const unsigned char *tables(int m Line 784  static const unsigned char *tables(int m
784                  return tables_copy;                  return tables_copy;
785    
786          default_tables = NULL;          default_tables = NULL;
787  #ifdef SUPPORT_PCRE8  #if defined SUPPORT_PCRE8
788          regex = pcre_compile(null_str, 0, &errorptr, &erroroffset, NULL);          regex = pcre_compile(null_str, 0, &errorptr, &erroroffset, NULL);
789          if (regex) {          if (regex) {
790                  pcre_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);                  pcre_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
791                  pcre_free(regex);                  pcre_free(regex);
792          }          }
793  #else  #elif defined SUPPORT_PCRE16
794          regex = pcre16_compile(null_str, 0, &errorptr, &erroroffset, NULL);          regex = pcre16_compile(null_str, 0, &errorptr, &erroroffset, NULL);
795          if (regex) {          if (regex) {
796                  pcre16_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);                  pcre16_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
797                  pcre16_free(regex);                  pcre16_free(regex);
798          }          }
799    #elif defined SUPPORT_PCRE32
800            regex = pcre32_compile(null_str, 0, &errorptr, &erroroffset, NULL);
801            if (regex) {
802                    pcre32_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
803                    pcre32_free(regex);
804            }
805  #endif  #endif
806          /* Shouldn't ever happen. */          /* Shouldn't ever happen. */
807          if (!default_tables)          if (!default_tables)
# Line 769  static pcre16_jit_stack* callback16(void Line 831  static pcre16_jit_stack* callback16(void
831  }  }
832  #endif  #endif
833    
834    #ifdef SUPPORT_PCRE32
835    static pcre32_jit_stack* callback32(void *arg)
836    {
837            return (pcre32_jit_stack *)arg;
838    }
839    #endif
840    
841  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
842  static void setstack8(pcre_extra *extra)  static pcre_jit_stack *stack8;
843    
844    static pcre_jit_stack *getstack8(void)
845  {  {
846          static pcre_jit_stack *stack;          if (!stack8)
847                    stack8 = pcre_jit_stack_alloc(1, 1024 * 1024);
848            return stack8;
849    }
850    
851    static void setstack8(pcre_extra *extra)
852    {
853          if (!extra) {          if (!extra) {
854                  if (stack)                  if (stack8)
855                          pcre_jit_stack_free(stack);                          pcre_jit_stack_free(stack8);
856                  stack = NULL;                  stack8 = NULL;
857                  return;                  return;
858          }          }
859    
860          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);  
861  }  }
862  #endif /* SUPPORT_PCRE8 */  #endif /* SUPPORT_PCRE8 */
863    
864  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
865    static pcre16_jit_stack *stack16;
866    
867    static pcre16_jit_stack *getstack16(void)
868    {
869            if (!stack16)
870                    stack16 = pcre16_jit_stack_alloc(1, 1024 * 1024);
871            return stack16;
872    }
873    
874  static void setstack16(pcre16_extra *extra)  static void setstack16(pcre16_extra *extra)
875  {  {
876          static pcre16_jit_stack *stack;          if (!extra) {
877                    if (stack16)
878                            pcre16_jit_stack_free(stack16);
879                    stack16 = NULL;
880                    return;
881            }
882    
883            pcre16_assign_jit_stack(extra, callback16, getstack16());
884    }
885    #endif /* SUPPORT_PCRE8 */
886    
887    #ifdef SUPPORT_PCRE32
888    static pcre32_jit_stack *stack32;
889    
890    static pcre32_jit_stack *getstack32(void)
891    {
892            if (!stack32)
893                    stack32 = pcre32_jit_stack_alloc(1, 1024 * 1024);
894            return stack32;
895    }
896    
897    static void setstack32(pcre32_extra *extra)
898    {
899          if (!extra) {          if (!extra) {
900                  if (stack)                  if (stack32)
901                          pcre16_jit_stack_free(stack);                          pcre32_jit_stack_free(stack32);
902                  stack = NULL;                  stack32 = NULL;
903                  return;                  return;
904          }          }
905    
906          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);  
907  }  }
908  #endif /* SUPPORT_PCRE8 */  #endif /* SUPPORT_PCRE8 */
909    
# Line 812  static void setstack16(pcre16_extra *ext Line 912  static void setstack16(pcre16_extra *ext
912  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)
913  {  {
914          unsigned char *iptr = (unsigned char*)input;          unsigned char *iptr = (unsigned char*)input;
915          unsigned short *optr = (unsigned short *)output;          PCRE_UCHAR16 *optr = output;
916          unsigned int c;          unsigned int c;
917    
918          if (max_length == 0)          if (max_length == 0)
# Line 841  static int convert_utf8_to_utf16(const c Line 941  static int convert_utf8_to_utf16(const c
941                          max_length--;                          max_length--;
942                  } else if (max_length <= 2) {                  } else if (max_length <= 2) {
943                          *optr = '\0';                          *optr = '\0';
944                          return (int)(optr - (unsigned short *)output);                          return (int)(optr - output);
945                  } else {                  } else {
946                          c -= 0x10000;                          c -= 0x10000;
947                          *optr++ = 0xd800 | ((c >> 10) & 0x3ff);                          *optr++ = 0xd800 | ((c >> 10) & 0x3ff);
# Line 854  static int convert_utf8_to_utf16(const c Line 954  static int convert_utf8_to_utf16(const c
954          if (offsetmap)          if (offsetmap)
955                  *offsetmap = (int)(iptr - (unsigned char*)input);                  *offsetmap = (int)(iptr - (unsigned char*)input);
956          *optr = '\0';          *optr = '\0';
957          return (int)(optr - (unsigned short *)output);          return (int)(optr - output);
958  }  }
959    
960  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)
961  {  {
962          unsigned char *iptr = (unsigned char*)input;          unsigned char *iptr = (unsigned char*)input;
963          unsigned short *optr = (unsigned short *)output;          PCRE_UCHAR16 *optr = output;
964    
965          if (max_length == 0)          if (max_length == 0)
966                  return 0;                  return 0;
# Line 870  static int copy_char8_to_char16(const ch Line 970  static int copy_char8_to_char16(const ch
970                  max_length--;                  max_length--;
971          }          }
972          *optr = '\0';          *optr = '\0';
973          return (int)(optr - (unsigned short *)output);          return (int)(optr - output);
974  }  }
975    
976  #define REGTEST_MAX_LENGTH 4096  #define REGTEST_MAX_LENGTH16 4096
977  static PCRE_UCHAR16 regtest_buf[REGTEST_MAX_LENGTH];  static PCRE_UCHAR16 regtest_buf16[REGTEST_MAX_LENGTH16];
978  static int regtest_offsetmap[REGTEST_MAX_LENGTH];  static int regtest_offsetmap16[REGTEST_MAX_LENGTH16];
979    
980  #endif /* SUPPORT_PCRE16 */  #endif /* SUPPORT_PCRE16 */
981    
982    #ifdef SUPPORT_PCRE32
983    
984    static int convert_utf8_to_utf32(const char *input, PCRE_UCHAR32 *output, int *offsetmap, int max_length)
985    {
986            unsigned char *iptr = (unsigned char*)input;
987            PCRE_UCHAR32 *optr = output;
988            unsigned int c;
989    
990            if (max_length == 0)
991                    return 0;
992    
993            while (*iptr && max_length > 1) {
994                    c = 0;
995                    if (offsetmap)
996                            *offsetmap++ = (int)(iptr - (unsigned char*)input);
997    
998                    if (!(*iptr & 0x80))
999                            c = *iptr++;
1000                    else if (!(*iptr & 0x20)) {
1001                            c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
1002                            iptr += 2;
1003                    } else if (!(*iptr & 0x10)) {
1004                            c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
1005                            iptr += 3;
1006                    } else if (!(*iptr & 0x08)) {
1007                            c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
1008                            iptr += 4;
1009                    }
1010    
1011                    *optr++ = c;
1012                    max_length--;
1013            }
1014            if (offsetmap)
1015                    *offsetmap = (int)(iptr - (unsigned char*)input);
1016            *optr = 0;
1017            return (int)(optr - output);
1018    }
1019    
1020    static int copy_char8_to_char32(const char *input, PCRE_UCHAR32 *output, int max_length)
1021    {
1022            unsigned char *iptr = (unsigned char*)input;
1023            PCRE_UCHAR32 *optr = output;
1024    
1025            if (max_length == 0)
1026                    return 0;
1027    
1028            while (*iptr && max_length > 1) {
1029                    *optr++ = *iptr++;
1030                    max_length--;
1031            }
1032            *optr = '\0';
1033            return (int)(optr - output);
1034    }
1035    
1036    #define REGTEST_MAX_LENGTH32 4096
1037    static PCRE_UCHAR32 regtest_buf32[REGTEST_MAX_LENGTH32];
1038    static int regtest_offsetmap32[REGTEST_MAX_LENGTH32];
1039    
1040    #endif /* SUPPORT_PCRE32 */
1041    
1042  static int check_ascii(const char *input)  static int check_ascii(const char *input)
1043  {  {
1044          const unsigned char *ptr = (unsigned char *)input;          const unsigned char *ptr = (unsigned char *)input;
# Line 902  static int regression_tests(void) Line 1062  static int regression_tests(void)
1062          int successful_row = 0;          int successful_row = 0;
1063          int counter = 0;          int counter = 0;
1064          int study_mode;          int study_mode;
1065            int utf = 0, ucp = 0;
1066            int disabled_flags = 0;
1067  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1068          pcre *re8;          pcre *re8;
1069          pcre_extra *extra8;          pcre_extra *extra8;
1070          pcre_extra dummy_extra8;          pcre_extra dummy_extra8;
1071          int ovector8_1[32];          int ovector8_1[32];
1072          int ovector8_2[32];          int ovector8_2[32];
1073          int return_value8_1, return_value8_2;          int return_value8[2];
1074          unsigned char *mark8_1, *mark8_2;          unsigned char *mark8_1, *mark8_2;
         int utf8 = 0, ucp8 = 0;  
         int disabled_flags8 = 0;  
1075  #endif  #endif
1076  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1077          pcre16 *re16;          pcre16 *re16;
# Line 919  static int regression_tests(void) Line 1079  static int regression_tests(void)
1079          pcre16_extra dummy_extra16;          pcre16_extra dummy_extra16;
1080          int ovector16_1[32];          int ovector16_1[32];
1081          int ovector16_2[32];          int ovector16_2[32];
1082          int return_value16_1, return_value16_2;          int return_value16[2];
1083          PCRE_UCHAR16 *mark16_1, *mark16_2;          PCRE_UCHAR16 *mark16_1, *mark16_2;
         int utf16 = 0, ucp16 = 0;  
         int disabled_flags16 = 0;  
1084          int length16;          int length16;
1085  #endif  #endif
1086    #ifdef SUPPORT_PCRE32
1087            pcre32 *re32;
1088            pcre32_extra *extra32;
1089            pcre32_extra dummy_extra32;
1090            int ovector32_1[32];
1091            int ovector32_2[32];
1092            int return_value32[2];
1093            PCRE_UCHAR32 *mark32_1, *mark32_2;
1094            int length32;
1095    #endif
1096    
1097          /* This test compares the behaviour of interpreter and JIT. Although disabling          /* This test compares the behaviour of interpreter and JIT. Although disabling
1098          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
1099          still considered successful from pcre_jit_test point of view. */          still considered successful from pcre_jit_test point of view. */
1100    
1101  #ifdef SUPPORT_PCRE8  #if defined SUPPORT_PCRE8
1102          pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);          pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1103  #else  #elif defined SUPPORT_PCRE16
1104          pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);          pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1105    #elif defined SUPPORT_PCRE32
1106            pcre32_config(PCRE_CONFIG_JITTARGET, &cpu_info);
1107  #endif  #endif
1108    
1109          printf("Running JIT regression tests\n");          printf("Running JIT regression tests\n");
1110          printf("  target CPU of SLJIT compiler: %s\n", cpu_info);          printf("  target CPU of SLJIT compiler: %s\n", cpu_info);
1111    
1112    #if defined SUPPORT_PCRE8
1113            pcre_config(PCRE_CONFIG_UTF8, &utf);
1114            pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1115    #elif defined SUPPORT_PCRE16
1116            pcre16_config(PCRE_CONFIG_UTF16, &utf);
1117            pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1118    #elif defined SUPPORT_PCRE16
1119            pcre32_config(PCRE_CONFIG_UTF32, &utf);
1120            pcre32_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
1121    #endif
1122    
1123            if (!utf)
1124                    disabled_flags |= PCRE_UTF8 | PCRE_UTF16 | PCRE_UTF32;
1125            if (!ucp)
1126                    disabled_flags |= PCRE_UCP;
1127  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1128          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");  
1129  #endif  #endif
1130  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1131          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");
1132          pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp16);  #endif
1133          if (!utf16)  #ifdef SUPPORT_PCRE32
1134                  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");  
1135  #endif  #endif
1136    
1137          while (current->pattern) {          while (current->pattern) {
# Line 980  static int regression_tests(void) Line 1156  static int regression_tests(void)
1156                  re8 = NULL;                  re8 = NULL;
1157                  if (!(current->start_offset & F_NO8))                  if (!(current->start_offset & F_NO8))
1158                          re8 = pcre_compile(current->pattern,                          re8 = pcre_compile(current->pattern,
1159                                  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),
1160                                  &error, &err_offs, tables(0));                                  &error, &err_offs, tables(0));
1161    
1162                  extra8 = NULL;                  extra8 = NULL;
# Line 992  static int regression_tests(void) Line 1168  static int regression_tests(void)
1168                                  pcre_free(re8);                                  pcre_free(re8);
1169                                  re8 = NULL;                                  re8 = NULL;
1170                          }                          }
1171                          if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {                          else if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1172                                  printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);                                  printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);
1173                                  pcre_free_study(extra8);                                  pcre_free_study(extra8);
1174                                  pcre_free(re8);                                  pcre_free(re8);
1175                                  re8 = NULL;                                  re8 = NULL;
1176                          }                          }
1177                          extra8->flags |= PCRE_EXTRA_MARK;                          extra8->flags |= PCRE_EXTRA_MARK;
1178                  } else if (((utf8 && ucp8) || is_ascii_pattern) && !(current->start_offset & F_NO8))                  } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO8))
1179                          printf("\n8 bit: Cannot compile pattern: %s\n", current->pattern);                          printf("\n8 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1180  #endif  #endif
1181  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1182                  if ((current->flags & PCRE_UTF8) || (current->start_offset & F_FORCECONV))                  if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
1183                          convert_utf8_to_utf16(current->pattern, regtest_buf, NULL, REGTEST_MAX_LENGTH);                          convert_utf8_to_utf16(current->pattern, regtest_buf16, NULL, REGTEST_MAX_LENGTH16);
1184                  else                  else
1185                          copy_char8_to_char16(current->pattern, regtest_buf, REGTEST_MAX_LENGTH);                          copy_char8_to_char16(current->pattern, regtest_buf16, REGTEST_MAX_LENGTH16);
1186    
1187                  re16 = NULL;                  re16 = NULL;
1188                  if (!(current->start_offset & F_NO16))                  if (!(current->start_offset & F_NO16))
1189                          re16 = pcre16_compile(regtest_buf,                          re16 = pcre16_compile(regtest_buf16,
1190                                  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),
1191                                  &error, &err_offs, tables(0));                                  &error, &err_offs, tables(0));
1192    
1193                  extra16 = NULL;                  extra16 = NULL;
# Line 1023  static int regression_tests(void) Line 1199  static int regression_tests(void)
1199                                  pcre16_free(re16);                                  pcre16_free(re16);
1200                                  re16 = NULL;                                  re16 = NULL;
1201                          }                          }
1202                          if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {                          else if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1203                                  printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);                                  printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);
1204                                  pcre16_free_study(extra16);                                  pcre16_free_study(extra16);
1205                                  pcre16_free(re16);                                  pcre16_free(re16);
1206                                  re16 = NULL;                                  re16 = NULL;
1207                          }                          }
1208                          extra16->flags |= PCRE_EXTRA_MARK;                          extra16->flags |= PCRE_EXTRA_MARK;
1209                  } else if (((utf16 && ucp16) || is_ascii_pattern) && !(current->start_offset & F_NO16))                  } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO16))
1210                          printf("\n16 bit: Cannot compile pattern: %s\n", current->pattern);                          printf("\n16 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1211    #endif
1212    #ifdef SUPPORT_PCRE32
1213                    if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
1214                            convert_utf8_to_utf32(current->pattern, regtest_buf32, NULL, REGTEST_MAX_LENGTH32);
1215                    else
1216                            copy_char8_to_char32(current->pattern, regtest_buf32, REGTEST_MAX_LENGTH32);
1217    
1218                    re32 = NULL;
1219                    if (!(current->start_offset & F_NO32))
1220                            re32 = pcre32_compile(regtest_buf32,
1221                                    current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
1222                                    &error, &err_offs, tables(0));
1223    
1224                    extra32 = NULL;
1225                    if (re32) {
1226                            error = NULL;
1227                            extra32 = pcre32_study(re32, study_mode, &error);
1228                            if (!extra32) {
1229                                    printf("\n32 bit: Cannot study pattern: %s\n", current->pattern);
1230                                    pcre32_free(re32);
1231                                    re32 = NULL;
1232                            }
1233                            if (!(extra32->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
1234                                    printf("\n32 bit: JIT compiler does not support: %s\n", current->pattern);
1235                                    pcre32_free_study(extra32);
1236                                    pcre32_free(re32);
1237                                    re32 = NULL;
1238                            }
1239                            extra32->flags |= PCRE_EXTRA_MARK;
1240                    } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO32))
1241                            printf("\n32 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
1242  #endif  #endif
1243    
1244                  counter++;                  counter++;
# Line 1042  static int regression_tests(void) Line 1249  static int regression_tests(void)
1249  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1250                          setstack16(NULL);                          setstack16(NULL);
1251  #endif  #endif
1252    #ifdef SUPPORT_PCRE32
1253                            setstack32(NULL);
1254    #endif
1255                  }                  }
1256    
1257  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1258                  return_value8_1 = -1000;                  return_value8[0] = -1000;
1259                  return_value8_2 = -1000;                  return_value8[1] = -1000;
1260                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
1261                          ovector8_1[i] = -2;                          ovector8_1[i] = -2;
1262                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
# Line 1054  static int regression_tests(void) Line 1264  static int regression_tests(void)
1264                  if (re8) {                  if (re8) {
1265                          mark8_1 = NULL;                          mark8_1 = NULL;
1266                          mark8_2 = NULL;                          mark8_2 = NULL;
                         setstack8(extra8);  
1267                          extra8->mark = &mark8_1;                          extra8->mark = &mark8_1;
1268                          return_value8_1 = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,  
1269                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32);                          if ((counter & 0x1) != 0) {
1270                                    setstack8(extra8);
1271                                    return_value8[0] = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1272                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32);
1273                            } else
1274                                    return_value8[0] = pcre_jit_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
1275                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32, getstack8());
1276                          memset(&dummy_extra8, 0, sizeof(pcre_extra));                          memset(&dummy_extra8, 0, sizeof(pcre_extra));
1277                          dummy_extra8.flags = PCRE_EXTRA_MARK;                          dummy_extra8.flags = PCRE_EXTRA_MARK;
1278                            if (current->start_offset & F_STUDY) {
1279                                    dummy_extra8.flags |= PCRE_EXTRA_STUDY_DATA;
1280                                    dummy_extra8.study_data = extra8->study_data;
1281                            }
1282                          dummy_extra8.mark = &mark8_2;                          dummy_extra8.mark = &mark8_2;
1283                          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,
1284                                  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);
1285                  }                  }
1286  #endif  #endif
1287    
1288  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1289                  return_value16_1 = -1000;                  return_value16[0] = -1000;
1290                  return_value16_2 = -1000;                  return_value16[1] = -1000;
1291                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
1292                          ovector16_1[i] = -2;                          ovector16_1[i] = -2;
1293                  for (i = 0; i < 32; ++i)                  for (i = 0; i < 32; ++i)
# Line 1076  static int regression_tests(void) Line 1295  static int regression_tests(void)
1295                  if (re16) {                  if (re16) {
1296                          mark16_1 = NULL;                          mark16_1 = NULL;
1297                          mark16_2 = NULL;                          mark16_2 = NULL;
1298                          setstack16(extra16);                          if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
1299                          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);  
1300                          else                          else
1301                                  length16 = copy_char8_to_char16(current->input, regtest_buf, REGTEST_MAX_LENGTH);                                  length16 = copy_char8_to_char16(current->input, regtest_buf16, REGTEST_MAX_LENGTH16);
1302                          extra16->mark = &mark16_1;                          extra16->mark = &mark16_1;
1303                          return_value16_1 = pcre16_exec(re16, extra16, regtest_buf, length16, current->start_offset & OFFSET_MASK,                          if ((counter & 0x1) != 0) {
1304                                  current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32);                                  setstack16(extra16);
1305                                    return_value16[0] = pcre16_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1306                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32);
1307                            } else
1308                                    return_value16[0] = pcre16_jit_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
1309                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32, getstack16());
1310                          memset(&dummy_extra16, 0, sizeof(pcre16_extra));                          memset(&dummy_extra16, 0, sizeof(pcre16_extra));
1311                          dummy_extra16.flags = PCRE_EXTRA_MARK;                          dummy_extra16.flags = PCRE_EXTRA_MARK;
1312                            if (current->start_offset & F_STUDY) {
1313                                    dummy_extra16.flags |= PCRE_EXTRA_STUDY_DATA;
1314                                    dummy_extra16.study_data = extra16->study_data;
1315                            }
1316                          dummy_extra16.mark = &mark16_2;                          dummy_extra16.mark = &mark16_2;
1317                          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,
1318                                  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);
1319                  }                  }
1320  #endif  #endif
1321    
1322                  /* 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
1323                    return_value32[0] = -1000;
1324                    return_value32[1] = -1000;
1325                    for (i = 0; i < 32; ++i)
1326                            ovector32_1[i] = -2;
1327                    for (i = 0; i < 32; ++i)
1328                            ovector32_2[i] = -2;
1329                    if (re32) {
1330                            mark32_1 = NULL;
1331                            mark32_2 = NULL;
1332                            if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
1333                                    length32 = convert_utf8_to_utf32(current->input, regtest_buf32, regtest_offsetmap32, REGTEST_MAX_LENGTH32);
1334                            else
1335                                    length32 = copy_char8_to_char32(current->input, regtest_buf32, REGTEST_MAX_LENGTH32);
1336                            extra32->mark = &mark32_1;
1337                            if ((counter & 0x1) != 0) {
1338                                    setstack32(extra32);
1339                                    return_value32[0] = pcre32_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1340                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_1, 32);
1341                            } else
1342                                    return_value32[0] = pcre32_jit_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1343                                            current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_1, 32, getstack32());
1344                            memset(&dummy_extra32, 0, sizeof(pcre32_extra));
1345                            dummy_extra32.flags = PCRE_EXTRA_MARK;
1346                            if (current->start_offset & F_STUDY) {
1347                                    dummy_extra32.flags |= PCRE_EXTRA_STUDY_DATA;
1348                                    dummy_extra32.study_data = extra32->study_data;
1349                            }
1350                            dummy_extra32.mark = &mark32_2;
1351                            return_value32[1] = pcre32_exec(re32, &dummy_extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
1352                                    current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_2, 32);
1353                    }
1354    #endif
1355    
1356                    /* printf("[%d-%d-%d|%d-%d|%d-%d|%d-%d]%s",
1357                            return_value8[0], return_value16[0],
1358                            ovector8_1[0], ovector8_1[1],
1359                            ovector16_1[0], ovector16_1[1],
1360                            ovector32_1[0], ovector32_1[1],
1361                            (current->flags & PCRE_CASELESS) ? "C" : ""); */
1362    
1363                  /* 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.
1364                  Segfaults can still be captured. */                  Segfaults can still be captured. */
1365    
1366                  is_successful = 1;                  is_successful = 1;
1367                  if (!(current->start_offset & F_DIFF)) {                  if (!(current->start_offset & F_DIFF)) {
1368  #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16  #if defined SUPPORT_UTF && ((defined(SUPPORT_PCRE8) + defined(SUPPORT_PCRE16) + defined(SUPPORT_PCRE32)) >= 2)
1369                          if (utf8 == utf16 && !(current->start_offset & F_FORCECONV)) {                          if (!(current->start_offset & F_FORCECONV)) {
1370                                    int return_value;
1371    
1372                                  /* All results must be the same. */                                  /* All results must be the same. */
1373                                  if (return_value8_1 != return_value8_2 || return_value8_1 != return_value16_1 || return_value8_1 != return_value16_2) {  #ifdef SUPPORT_PCRE8
1374                                          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]) {
1375                                                  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",
1376                                                    return_value8[0], return_value8[1], total, current->pattern, current->input);
1377                                            is_successful = 0;
1378                                    } else
1379    #endif
1380    #ifdef SUPPORT_PCRE16
1381                                    if ((return_value = return_value16[0]) != return_value16[1]) {
1382                                            printf("\n16 bit: Return value differs(J16:%d,I16:%d): [%d] '%s' @ '%s'\n",
1383                                                    return_value16[0], return_value16[1], total, current->pattern, current->input);
1384                                            is_successful = 0;
1385                                    } else
1386    #endif
1387    #ifdef SUPPORT_PCRE32
1388                                    if ((return_value = return_value32[0]) != return_value32[1]) {
1389                                            printf("\n32 bit: Return value differs(J32:%d,I32:%d): [%d] '%s' @ '%s'\n",
1390                                                    return_value32[0], return_value32[1], total, current->pattern, current->input);
1391                                            is_successful = 0;
1392                                    } else
1393    #endif
1394    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
1395                                    if (return_value8[0] != return_value16[0]) {
1396                                            printf("\n8 and 16 bit: Return value differs(J8:%d,J16:%d): [%d] '%s' @ '%s'\n",
1397                                                    return_value8[0], return_value16[0],
1398                                                    total, current->pattern, current->input);
1399                                            is_successful = 0;
1400                                    } else
1401    #endif
1402    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
1403                                    if (return_value8[0] != return_value32[0]) {
1404                                            printf("\n8 and 32 bit: Return value differs(J8:%d,J32:%d): [%d] '%s' @ '%s'\n",
1405                                                    return_value8[0], return_value32[0],
1406                                                    total, current->pattern, current->input);
1407                                            is_successful = 0;
1408                                    } else
1409    #endif
1410    #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE32
1411                                    if (return_value16[0] != return_value32[0]) {
1412                                            printf("\n16 and 32 bit: Return value differs(J16:%d,J32:%d): [%d] '%s' @ '%s'\n",
1413                                                    return_value16[0], return_value32[0],
1414                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1415                                          is_successful = 0;                                          is_successful = 0;
1416                                  } else if (return_value8_1 >= 0 || return_value8_1 == PCRE_ERROR_PARTIAL) {                                  } else
1417                                          if (return_value8_1 == PCRE_ERROR_PARTIAL) {  #endif
1418                                                  return_value8_1 = 2;                                  if (return_value >= 0 || return_value == PCRE_ERROR_PARTIAL) {
1419                                                  return_value16_1 = 2;                                          if (return_value == PCRE_ERROR_PARTIAL) {
1420                                                    return_value = 2;
1421                                          } else {                                          } else {
1422                                                  return_value8_1 *= 2;                                                  return_value *= 2;
                                                 return_value16_1 *= 2;  
1423                                          }                                          }
1424    #ifdef SUPPORT_PCRE8
1425                                            return_value8[0] = return_value;
1426    #endif
1427    #ifdef SUPPORT_PCRE16
1428                                            return_value16[0] = return_value;
1429    #endif
1430    #ifdef SUPPORT_PCRE32
1431                                            return_value32[0] = return_value;
1432    #endif
1433                                          /* Transform back the results. */                                          /* Transform back the results. */
1434                                          if (current->flags & PCRE_UTF8) {                                          if (current->flags & PCRE_UTF8) {
1435                                                  for (i = 0; i < return_value8_1; ++i) {  #ifdef SUPPORT_PCRE16
1436                                                    for (i = 0; i < return_value; ++i) {
1437                                                          if (ovector16_1[i] >= 0)                                                          if (ovector16_1[i] >= 0)
1438                                                                  ovector16_1[i] = regtest_offsetmap[ovector16_1[i]];                                                                  ovector16_1[i] = regtest_offsetmap16[ovector16_1[i]];
1439                                                          if (ovector16_2[i] >= 0)                                                          if (ovector16_2[i] >= 0)
1440                                                                  ovector16_2[i] = regtest_offsetmap[ovector16_2[i]];                                                                  ovector16_2[i] = regtest_offsetmap16[ovector16_2[i]];
1441                                                  }                                                  }
1442    #endif
1443    #ifdef SUPPORT_PCRE32
1444                                                    for (i = 0; i < return_value; ++i) {
1445                                                            if (ovector32_1[i] >= 0)
1446                                                                    ovector32_1[i] = regtest_offsetmap32[ovector32_1[i]];
1447                                                            if (ovector32_2[i] >= 0)
1448                                                                    ovector32_2[i] = regtest_offsetmap32[ovector32_2[i]];
1449                                                    }
1450    #endif
1451                                          }                                          }
1452    
1453                                          for (i = 0; i < return_value8_1; ++i)                                          for (i = 0; i < return_value; ++i) {
1454    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
1455                                                  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]) {
1456                                                          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",
1457                                                                  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],
1458                                                                  total, current->pattern, current->input);                                                                  total, current->pattern, current->input);
1459                                                          is_successful = 0;                                                          is_successful = 0;
1460                                                  }                                                  }
1461    #endif
1462    #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
1463                                                    if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector32_1[i] || ovector8_1[i] != ovector32_2[i]) {
1464                                                            printf("\n8 and 32 bit: Ovector[%d] value differs(J8:%d,I8:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
1465                                                                    i, ovector8_1[i], ovector8_2[i], ovector32_1[i], ovector32_2[i],
1466                                                                    total, current->pattern, current->input);
1467                                                            is_successful = 0;
1468                                                    }
1469    #endif
1470    #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE16
1471                                                    if (ovector16_1[i] != ovector16_2[i] || ovector16_1[i] != ovector16_1[i] || ovector16_1[i] != ovector16_2[i]) {
1472                                                            printf("\n16 and 16 bit: Ovector[%d] value differs(J16:%d,I16:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
1473                                                                    i, ovector16_1[i], ovector16_2[i], ovector16_1[i], ovector16_2[i],
1474                                                                    total, current->pattern, current->input);
1475                                                            is_successful = 0;
1476                                                    }
1477    #endif
1478                                            }
1479                                  }                                  }
1480                          } else {                          } else
1481  #endif /* SUPPORT_PCRE8 && SUPPORT_PCRE16 */  #endif /* more than one of SUPPORT_PCRE8, SUPPORT_PCRE16 and SUPPORT_PCRE32 */
1482                            {
1483                                  /* Only the 8 bit and 16 bit results must be equal. */                                  /* Only the 8 bit and 16 bit results must be equal. */
1484  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1485                                  if (return_value8_1 != return_value8_2) {                                  if (return_value8[0] != return_value8[1]) {
1486                                          printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",                                          printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1487                                                  return_value8_1, return_value8_2, total, current->pattern, current->input);                                                  return_value8[0], return_value8[1], total, current->pattern, current->input);
1488                                          is_successful = 0;                                          is_successful = 0;
1489                                  } else if (return_value8_1 >= 0 || return_value8_1 == PCRE_ERROR_PARTIAL) {                                  } else if (return_value8[0] >= 0 || return_value8[0] == PCRE_ERROR_PARTIAL) {
1490                                          if (return_value8_1 == PCRE_ERROR_PARTIAL)                                          if (return_value8[0] == PCRE_ERROR_PARTIAL)
1491                                                  return_value8_1 = 2;                                                  return_value8[0] = 2;
1492                                          else                                          else
1493                                                  return_value8_1 *= 2;                                                  return_value8[0] *= 2;
1494    
1495                                          for (i = 0; i < return_value8_1; ++i)                                          for (i = 0; i < return_value8[0]; ++i)
1496                                                  if (ovector8_1[i] != ovector8_2[i]) {                                                  if (ovector8_1[i] != ovector8_2[i]) {
1497                                                          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",
1498                                                                  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 1502  static int regression_tests(void)
1502  #endif  #endif
1503    
1504  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1505                                  if (return_value16_1 != return_value16_2) {                                  if (return_value16[0] != return_value16[1]) {
1506                                          printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",                                          printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1507                                                  return_value16_1, return_value16_2, total, current->pattern, current->input);                                                  return_value16[0], return_value16[1], total, current->pattern, current->input);
1508                                          is_successful = 0;                                          is_successful = 0;
1509                                  } else if (return_value16_1 >= 0 || return_value16_1 == PCRE_ERROR_PARTIAL) {                                  } else if (return_value16[0] >= 0 || return_value16[0] == PCRE_ERROR_PARTIAL) {
1510                                          if (return_value16_1 == PCRE_ERROR_PARTIAL)                                          if (return_value16[0] == PCRE_ERROR_PARTIAL)
1511                                                  return_value16_1 = 2;                                                  return_value16[0] = 2;
1512                                          else                                          else
1513                                                  return_value16_1 *= 2;                                                  return_value16[0] *= 2;
1514    
1515                                          for (i = 0; i < return_value16_1; ++i)                                          for (i = 0; i < return_value16[0]; ++i)
1516                                                  if (ovector16_1[i] != ovector16_2[i]) {                                                  if (ovector16_1[i] != ovector16_2[i]) {
1517                                                          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",
1518                                                                  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 1521  static int regression_tests(void)
1521                                  }                                  }
1522  #endif  #endif
1523    
1524  #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16  #ifdef SUPPORT_PCRE32
1525                                    if (return_value32[0] != return_value32[1]) {
1526                                            printf("\n32 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
1527                                                    return_value32[0], return_value32[1], total, current->pattern, current->input);
1528                                            is_successful = 0;
1529                                    } else if (return_value32[0] >= 0 || return_value32[0] == PCRE_ERROR_PARTIAL) {
1530                                            if (return_value32[0] == PCRE_ERROR_PARTIAL)
1531                                                    return_value32[0] = 2;
1532                                            else
1533                                                    return_value32[0] *= 2;
1534    
1535                                            for (i = 0; i < return_value32[0]; ++i)
1536                                                    if (ovector32_1[i] != ovector32_2[i]) {
1537                                                            printf("\n32 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
1538                                                                    i, ovector32_1[i], ovector32_2[i], total, current->pattern, current->input);
1539                                                            is_successful = 0;
1540                                                    }
1541                                    }
1542    #endif
1543                          }                          }
 #endif /* SUPPORT_PCRE8 && SUPPORT_PCRE16 */  
1544                  }                  }
1545    
1546                  if (is_successful) {                  if (is_successful) {
1547  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
1548                          if (!(current->start_offset & F_NO8) && ((utf8 && ucp8) || is_ascii_input)) {                          if (!(current->start_offset & F_NO8) && ((utf && ucp) || is_ascii_input)) {
1549                                  if (return_value8_1 < 0 && !(current->start_offset & F_NOMATCH)) {                                  if (return_value8[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1550                                          printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",                                          printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",
1551                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1552                                          is_successful = 0;                                          is_successful = 0;
1553                                  }                                  }
1554    
1555                                  if (return_value8_1 >= 0 && (current->start_offset & F_NOMATCH)) {                                  if (return_value8[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1556                                          printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",                                          printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",
1557                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1558                                          is_successful = 0;                                          is_successful = 0;
# Line 1199  static int regression_tests(void) Line 1560  static int regression_tests(void)
1560                          }                          }
1561  #endif  #endif
1562  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1563                          if (!(current->start_offset & F_NO16) && ((utf16 && ucp16) || is_ascii_input)) {                          if (!(current->start_offset & F_NO16) && ((utf && ucp) || is_ascii_input)) {
1564                                  if (return_value16_1 < 0 && !(current->start_offset & F_NOMATCH)) {                                  if (return_value16[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1565                                          printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",                                          printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",
1566                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1567                                          is_successful = 0;                                          is_successful = 0;
1568                                  }                                  }
1569    
1570                                  if (return_value16_1 >= 0 && (current->start_offset & F_NOMATCH)) {                                  if (return_value16[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1571                                          printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",                                          printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",
1572                                                  total, current->pattern, current->input);                                                  total, current->pattern, current->input);
1573                                          is_successful = 0;                                          is_successful = 0;
1574                                  }                                  }
1575                          }                          }
1576  #endif  #endif
1577    #ifdef SUPPORT_PCRE32
1578                            if (!(current->start_offset & F_NO32) && ((utf && ucp) || is_ascii_input)) {
1579                                    if (return_value32[0] < 0 && !(current->start_offset & F_NOMATCH)) {
1580                                            printf("32 bit: Test should match: [%d] '%s' @ '%s'\n",
1581                                                    total, current->pattern, current->input);
1582                                            is_successful = 0;
1583                                    }
1584    
1585                                    if (return_value32[0] >= 0 && (current->start_offset & F_NOMATCH)) {
1586                                            printf("32 bit: Test should not match: [%d] '%s' @ '%s'\n",
1587                                                    total, current->pattern, current->input);
1588                                            is_successful = 0;
1589                                    }
1590                            }
1591    #endif
1592                  }                  }
1593    
1594                  if (is_successful) {                  if (is_successful) {
# Line 1230  static int regression_tests(void) Line 1606  static int regression_tests(void)
1606                                  is_successful = 0;                                  is_successful = 0;
1607                          }                          }
1608  #endif  #endif
1609    #ifdef SUPPORT_PCRE32
1610                            if (mark32_1 != mark32_2) {
1611                                    printf("32 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
1612                                            total, current->pattern, current->input);
1613                                    is_successful = 0;
1614                            }
1615    #endif
1616                  }                  }
1617    
1618  #ifdef SUPPORT_PCRE8  #ifdef SUPPORT_PCRE8
# Line 1244  static int regression_tests(void) Line 1627  static int regression_tests(void)
1627                          pcre16_free(re16);                          pcre16_free(re16);
1628                  }                  }
1629  #endif  #endif
1630    #ifdef SUPPORT_PCRE32
1631                    if (re32) {
1632                            pcre32_free_study(extra32);
1633                            pcre32_free(re32);
1634                    }
1635    #endif
1636    
1637                  if (is_successful) {                  if (is_successful) {
1638                          successful++;                          successful++;
# Line 1266  static int regression_tests(void) Line 1655  static int regression_tests(void)
1655  #ifdef SUPPORT_PCRE16  #ifdef SUPPORT_PCRE16
1656          setstack16(NULL);          setstack16(NULL);
1657  #endif  #endif
1658    #ifdef SUPPORT_PCRE32
1659            setstack32(NULL);
1660    #endif
1661    
1662          if (total == successful) {          if (total == successful) {
1663                  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.1282

  ViewVC Help
Powered by ViewVC 1.1.5