Free up bit for regex ANYOF nodes

This commit frees up a bit by using an extra regnode to pass the
information to the regex engine instead of the flag.  I originally
thought that if this was needed, it should be the ANYOF_ABOVE_LATIN1_ALL
bit, as that might speed some things up.  But if we need to do this
again by adding another node to get another bit, we want one that is
mutually exclusive of the first one we did, For otherwise we start
having to make 3 nodes instead of two to get the combinations:
 1 0
 0 1
 1 1

This combinatorial problem is avoided by using bits that are mutually
exclusive, which the ABOVE_LATIN1_ALL isn't, but the one freed by this
commit ANYOF_NON_UTF8_NON_ASCII_ALL is only set under /d matching, and
there are other bits that are set only under /l, so if we need to do
this again, we should use one of those.

I wrote this code when I thought I really needed a bit.  But since, I
have figured out a better way to get the bit needed now.  But I don't
want to lose this code to posterity, so this commit is being made long
enough to get the commit number, then it will be reverted, adding
comments referring to the commit number, so that it can easily be
reconstructed when necessary.

1 files changed, 155 insertions, 150 deletions

diff --git a/regnodes.h b/regnodes.h
index f9d4fc05dd..f9de6c39a9 100644
--- a/regnodes.h
+++ b/regnodes.h
@@ -6,8 +6,8 @@
 
 /* Regops and State definitions */
 
-#define REGNODE_MAX           	93
-#define REGMATCH_STATE_MAX    	133
+#define REGNODE_MAX           	94
+#define REGMATCH_STATE_MAX    	134
 
 #define	END                   	0	/* 0000 End of program. */
 #define	SUCCEED               	1	/* 0x01 Return from a subroutine, basically. */
@@ -31,78 +31,79 @@
 #define	SANY                  	19	/* 0x13 Match any one character. */
 #define	CANY                  	20	/* 0x14 Match any one byte. */
 #define	ANYOF                 	21	/* 0x15 Match character in (or not in) this class, single char match only */
-#define	POSIXD                	22	/* 0x16 Some [[:class:]] under /d; the FLAGS field gives which one */
-#define	POSIXL                	23	/* 0x17 Some [[:class:]] under /l; the FLAGS field gives which one */
-#define	POSIXU                	24	/* 0x18 Some [[:class:]] under /u; the FLAGS field gives which one */
-#define	POSIXA                	25	/* 0x19 Some [[:class:]] under /a; the FLAGS field gives which one */
-#define	NPOSIXD               	26	/* 0x1a complement of POSIXD, [[:^class:]] */
-#define	NPOSIXL               	27	/* 0x1b complement of POSIXL, [[:^class:]] */
-#define	NPOSIXU               	28	/* 0x1c complement of POSIXU, [[:^class:]] */
-#define	NPOSIXA               	29	/* 0x1d complement of POSIXA, [[:^class:]] */
-#define	CLUMP                 	30	/* 0x1e Match any extended grapheme cluster sequence */
-#define	BRANCH                	31	/* 0x1f Match this alternative, or the next... */
-#define	BACK                  	32	/* 0x20 Match "", "next" ptr points backward. */
-#define	EXACT                 	33	/* 0x21 Match this string (preceded by length). */
-#define	EXACTF                	34	/* 0x22 Match this non-UTF-8 string (not guaranteed to be folded) using /id rules (w/len). */
-#define	EXACTFL               	35	/* 0x23 Match this string (not guaranteed to be folded) using /il rules (w/len). */
-#define	EXACTFU               	36	/* 0x24 Match this string (folded iff in UTF-8, length in folding doesn't change if not in UTF-8) using /iu rules (w/len). */
-#define	EXACTFA               	37	/* 0x25 Match this string (not guaranteed to be folded) using /iaa rules (w/len). */
-#define	EXACTFU_SS            	38	/* 0x26 Match this string (folded iff in UTF-8, length in folding may change even if not in UTF-8) using /iu rules (w/len). */
-#define	EXACTFA_NO_TRIE       	39	/* 0x27 Match this string (which is not trie-able; not guaranteed to be folded) using /iaa rules (w/len). */
-#define	NOTHING               	40	/* 0x28 Match empty string. */
-#define	TAIL                  	41	/* 0x29 Match empty string. Can jump here from outside. */
-#define	STAR                  	42	/* 0x2a Match this (simple) thing 0 or more times. */
-#define	PLUS                  	43	/* 0x2b Match this (simple) thing 1 or more times. */
-#define	CURLY                 	44	/* 0x2c Match this simple thing {n,m} times. */
-#define	CURLYN                	45	/* 0x2d Capture next-after-this simple thing */
-#define	CURLYM                	46	/* 0x2e Capture this medium-complex thing {n,m} times. */
-#define	CURLYX                	47	/* 0x2f Match this complex thing {n,m} times. */
-#define	WHILEM                	48	/* 0x30 Do curly processing and see if rest matches. */
-#define	OPEN                  	49	/* 0x31 Mark this point in input as start of #n. */
-#define	CLOSE                 	50	/* 0x32 Analogous to OPEN. */
-#define	REF                   	51	/* 0x33 Match some already matched string */
-#define	REFF                  	52	/* 0x34 Match already matched string, folded using native charset semantics for non-utf8 */
-#define	REFFL                 	53	/* 0x35 Match already matched string, folded in loc. */
-#define	REFFU                 	54	/* 0x36 Match already matched string, folded using unicode semantics for non-utf8 */
-#define	REFFA                 	55	/* 0x37 Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */
-#define	NREF                  	56	/* 0x38 Match some already matched string */
-#define	NREFF                 	57	/* 0x39 Match already matched string, folded using native charset semantics for non-utf8 */
-#define	NREFFL                	58	/* 0x3a Match already matched string, folded in loc. */
-#define	NREFFU                	59	/* 0x3b Match already matched string, folded using unicode semantics for non-utf8 */
-#define	NREFFA                	60	/* 0x3c Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */
-#define	IFMATCH               	61	/* 0x3d Succeeds if the following matches. */
-#define	UNLESSM               	62	/* 0x3e Fails if the following matches. */
-#define	SUSPEND               	63	/* 0x3f "Independent" sub-RE. */
-#define	IFTHEN                	64	/* 0x40 Switch, should be preceded by switcher. */
-#define	GROUPP                	65	/* 0x41 Whether the group matched. */
-#define	LONGJMP               	66	/* 0x42 Jump far away. */
-#define	BRANCHJ               	67	/* 0x43 BRANCH with long offset. */
-#define	EVAL                  	68	/* 0x44 Execute some Perl code. */
-#define	MINMOD                	69	/* 0x45 Next operator is not greedy. */
-#define	LOGICAL               	70	/* 0x46 Next opcode should set the flag only. */
-#define	RENUM                 	71	/* 0x47 Group with independently numbered parens. */
-#define	TRIE                  	72	/* 0x48 Match many EXACT(F[ALU]?)? at once. flags==type */
-#define	TRIEC                 	73	/* 0x49 Same as TRIE, but with embedded charclass data */
-#define	AHOCORASICK           	74	/* 0x4a Aho Corasick stclass. flags==type */
-#define	AHOCORASICKC          	75	/* 0x4b Same as AHOCORASICK, but with embedded charclass data */
-#define	GOSUB                 	76	/* 0x4c recurse to paren arg1 at (signed) ofs arg2 */
-#define	GOSTART               	77	/* 0x4d recurse to start of pattern */
-#define	NGROUPP               	78	/* 0x4e Whether the group matched. */
-#define	INSUBP                	79	/* 0x4f Whether we are in a specific recurse. */
-#define	DEFINEP               	80	/* 0x50 Never execute directly. */
-#define	ENDLIKE               	81	/* 0x51 Used only for the type field of verbs */
-#define	OPFAIL                	82	/* 0x52 Same as (?!) */
-#define	ACCEPT                	83	/* 0x53 Accepts the current matched string. */
-#define	VERB                  	84	/* 0x54 Used only for the type field of verbs */
-#define	PRUNE                 	85	/* 0x55 Pattern fails at this startpoint if no-backtracking through this */
-#define	MARKPOINT             	86	/* 0x56 Push the current location for rollback by cut. */
-#define	SKIP                  	87	/* 0x57 On failure skip forward (to the mark) before retrying */
-#define	COMMIT                	88	/* 0x58 Pattern fails outright if backtracking through this */
-#define	CUTGROUP              	89	/* 0x59 On failure go to the next alternation in the group */
-#define	KEEPS                 	90	/* 0x5a $& begins here. */
-#define	LNBREAK               	91	/* 0x5b generic newline pattern */
-#define	OPTIMIZED             	92	/* 0x5c Placeholder for dump. */
-#define	PSEUDO                	93	/* 0x5d Pseudo opcode for internal use. */
+#define	ANYOF_NON_UTF8_NON_ASCII_ALL	22	/* 0x16 like ANYOF, also matches any U+80 - U+FF when not in UTF-8 */
+#define	POSIXD                	23	/* 0x17 Some [[:class:]] under /d; the FLAGS field gives which one */
+#define	POSIXL                	24	/* 0x18 Some [[:class:]] under /l; the FLAGS field gives which one */
+#define	POSIXU                	25	/* 0x19 Some [[:class:]] under /u; the FLAGS field gives which one */
+#define	POSIXA                	26	/* 0x1a Some [[:class:]] under /a; the FLAGS field gives which one */
+#define	NPOSIXD               	27	/* 0x1b complement of POSIXD, [[:^class:]] */
+#define	NPOSIXL               	28	/* 0x1c complement of POSIXL, [[:^class:]] */
+#define	NPOSIXU               	29	/* 0x1d complement of POSIXU, [[:^class:]] */
+#define	NPOSIXA               	30	/* 0x1e complement of POSIXA, [[:^class:]] */
+#define	CLUMP                 	31	/* 0x1f Match any extended grapheme cluster sequence */
+#define	BRANCH                	32	/* 0x20 Match this alternative, or the next... */
+#define	BACK                  	33	/* 0x21 Match "", "next" ptr points backward. */
+#define	EXACT                 	34	/* 0x22 Match this string (preceded by length). */
+#define	EXACTF                	35	/* 0x23 Match this non-UTF-8 string (not guaranteed to be folded) using /id rules (w/len). */
+#define	EXACTFL               	36	/* 0x24 Match this string (not guaranteed to be folded) using /il rules (w/len). */
+#define	EXACTFU               	37	/* 0x25 Match this string (folded iff in UTF-8, length in folding doesn't change if not in UTF-8) using /iu rules (w/len). */
+#define	EXACTFA               	38	/* 0x26 Match this string (not guaranteed to be folded) using /iaa rules (w/len). */
+#define	EXACTFU_SS            	39	/* 0x27 Match this string (folded iff in UTF-8, length in folding may change even if not in UTF-8) using /iu rules (w/len). */
+#define	EXACTFA_NO_TRIE       	40	/* 0x28 Match this string (which is not trie-able; not guaranteed to be folded) using /iaa rules (w/len). */
+#define	NOTHING               	41	/* 0x29 Match empty string. */
+#define	TAIL                  	42	/* 0x2a Match empty string. Can jump here from outside. */
+#define	STAR                  	43	/* 0x2b Match this (simple) thing 0 or more times. */
+#define	PLUS                  	44	/* 0x2c Match this (simple) thing 1 or more times. */
+#define	CURLY                 	45	/* 0x2d Match this simple thing {n,m} times. */
+#define	CURLYN                	46	/* 0x2e Capture next-after-this simple thing */
+#define	CURLYM                	47	/* 0x2f Capture this medium-complex thing {n,m} times. */
+#define	CURLYX                	48	/* 0x30 Match this complex thing {n,m} times. */
+#define	WHILEM                	49	/* 0x31 Do curly processing and see if rest matches. */
+#define	OPEN                  	50	/* 0x32 Mark this point in input as start of #n. */
+#define	CLOSE                 	51	/* 0x33 Analogous to OPEN. */
+#define	REF                   	52	/* 0x34 Match some already matched string */
+#define	REFF                  	53	/* 0x35 Match already matched string, folded using native charset semantics for non-utf8 */
+#define	REFFL                 	54	/* 0x36 Match already matched string, folded in loc. */
+#define	REFFU                 	55	/* 0x37 Match already matched string, folded using unicode semantics for non-utf8 */
+#define	REFFA                 	56	/* 0x38 Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */
+#define	NREF                  	57	/* 0x39 Match some already matched string */
+#define	NREFF                 	58	/* 0x3a Match already matched string, folded using native charset semantics for non-utf8 */
+#define	NREFFL                	59	/* 0x3b Match already matched string, folded in loc. */
+#define	NREFFU                	60	/* 0x3c Match already matched string, folded using unicode semantics for non-utf8 */
+#define	NREFFA                	61	/* 0x3d Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */
+#define	IFMATCH               	62	/* 0x3e Succeeds if the following matches. */
+#define	UNLESSM               	63	/* 0x3f Fails if the following matches. */
+#define	SUSPEND               	64	/* 0x40 "Independent" sub-RE. */
+#define	IFTHEN                	65	/* 0x41 Switch, should be preceded by switcher. */
+#define	GROUPP                	66	/* 0x42 Whether the group matched. */
+#define	LONGJMP               	67	/* 0x43 Jump far away. */
+#define	BRANCHJ               	68	/* 0x44 BRANCH with long offset. */
+#define	EVAL                  	69	/* 0x45 Execute some Perl code. */
+#define	MINMOD                	70	/* 0x46 Next operator is not greedy. */
+#define	LOGICAL               	71	/* 0x47 Next opcode should set the flag only. */
+#define	RENUM                 	72	/* 0x48 Group with independently numbered parens. */
+#define	TRIE                  	73	/* 0x49 Match many EXACT(F[ALU]?)? at once. flags==type */
+#define	TRIEC                 	74	/* 0x4a Same as TRIE, but with embedded charclass data */
+#define	AHOCORASICK           	75	/* 0x4b Aho Corasick stclass. flags==type */
+#define	AHOCORASICKC          	76	/* 0x4c Same as AHOCORASICK, but with embedded charclass data */
+#define	GOSUB                 	77	/* 0x4d recurse to paren arg1 at (signed) ofs arg2 */
+#define	GOSTART               	78	/* 0x4e recurse to start of pattern */
+#define	NGROUPP               	79	/* 0x4f Whether the group matched. */
+#define	INSUBP                	80	/* 0x50 Whether we are in a specific recurse. */
+#define	DEFINEP               	81	/* 0x51 Never execute directly. */
+#define	ENDLIKE               	82	/* 0x52 Used only for the type field of verbs */
+#define	OPFAIL                	83	/* 0x53 Same as (?!) */
+#define	ACCEPT                	84	/* 0x54 Accepts the current matched string. */
+#define	VERB                  	85	/* 0x55 Used only for the type field of verbs */
+#define	PRUNE                 	86	/* 0x56 Pattern fails at this startpoint if no-backtracking through this */
+#define	MARKPOINT             	87	/* 0x57 Push the current location for rollback by cut. */
+#define	SKIP                  	88	/* 0x58 On failure skip forward (to the mark) before retrying */
+#define	COMMIT                	89	/* 0x59 Pattern fails outright if backtracking through this */
+#define	CUTGROUP              	90	/* 0x5a On failure go to the next alternation in the group */
+#define	KEEPS                 	91	/* 0x5b $& begins here. */
+#define	LNBREAK               	92	/* 0x5c generic newline pattern */
+#define	OPTIMIZED             	93	/* 0x5d Placeholder for dump. */
+#define	PSEUDO                	94	/* 0x5e Pseudo opcode for internal use. */
 	/* ------------ States ------------- */
 #define	TRIE_next             	(REGNODE_MAX + 1)	/* state for TRIE */
 #define	TRIE_next_fail        	(REGNODE_MAX + 2)	/* state for TRIE */
@@ -173,6 +174,7 @@ EXTCONST U8 PL_regkind[] = {
 	REG_ANY,  	/* SANY                   */
 	REG_ANY,  	/* CANY                   */
 	ANYOF,    	/* ANYOF                  */
+	ANYOF,    	/* ANYOF_NON_UTF8_NON_ASCII_ALL */
 	POSIXD,   	/* POSIXD                 */
 	POSIXD,   	/* POSIXL                 */
 	POSIXD,   	/* POSIXU                 */
@@ -315,6 +317,7 @@ static const U8 regarglen[] = {
 	0,                                   	/* SANY         */
 	0,                                   	/* CANY         */
 	0,                                   	/* ANYOF        */
+	0,                                   	/* ANYOF_NON_UTF8_NON_ASCII_ALL */
 	0,                                   	/* POSIXD       */
 	0,                                   	/* POSIXL       */
 	0,                                   	/* POSIXU       */
@@ -414,6 +417,7 @@ static const char reg_off_by_arg[] = {
 	0,	/* SANY         */
 	0,	/* CANY         */
 	0,	/* ANYOF        */
+	0,	/* ANYOF_NON_UTF8_NON_ASCII_ALL */
 	0,	/* POSIXD       */
 	0,	/* POSIXL       */
 	0,	/* POSIXU       */
@@ -518,78 +522,79 @@ EXTCONST char * const PL_reg_name[] = {
 	"SANY",                  	/* 0x13 */
 	"CANY",                  	/* 0x14 */
 	"ANYOF",                 	/* 0x15 */
-	"POSIXD",                	/* 0x16 */
-	"POSIXL",                	/* 0x17 */
-	"POSIXU",                	/* 0x18 */
-	"POSIXA",                	/* 0x19 */
-	"NPOSIXD",               	/* 0x1a */
-	"NPOSIXL",               	/* 0x1b */
-	"NPOSIXU",               	/* 0x1c */
-	"NPOSIXA",               	/* 0x1d */
-	"CLUMP",                 	/* 0x1e */
-	"BRANCH",                	/* 0x1f */
-	"BACK",                  	/* 0x20 */
-	"EXACT",                 	/* 0x21 */
-	"EXACTF",                	/* 0x22 */
-	"EXACTFL",               	/* 0x23 */
-	"EXACTFU",               	/* 0x24 */
-	"EXACTFA",               	/* 0x25 */
-	"EXACTFU_SS",            	/* 0x26 */
-	"EXACTFA_NO_TRIE",       	/* 0x27 */
-	"NOTHING",               	/* 0x28 */
-	"TAIL",                  	/* 0x29 */
-	"STAR",                  	/* 0x2a */
-	"PLUS",                  	/* 0x2b */
-	"CURLY",                 	/* 0x2c */
-	"CURLYN",                	/* 0x2d */
-	"CURLYM",                	/* 0x2e */
-	"CURLYX",                	/* 0x2f */
-	"WHILEM",                	/* 0x30 */
-	"OPEN",                  	/* 0x31 */
-	"CLOSE",                 	/* 0x32 */
-	"REF",                   	/* 0x33 */
-	"REFF",                  	/* 0x34 */
-	"REFFL",                 	/* 0x35 */
-	"REFFU",                 	/* 0x36 */
-	"REFFA",                 	/* 0x37 */
-	"NREF",                  	/* 0x38 */
-	"NREFF",                 	/* 0x39 */
-	"NREFFL",                	/* 0x3a */
-	"NREFFU",                	/* 0x3b */
-	"NREFFA",                	/* 0x3c */
-	"IFMATCH",               	/* 0x3d */
-	"UNLESSM",               	/* 0x3e */
-	"SUSPEND",               	/* 0x3f */
-	"IFTHEN",                	/* 0x40 */
-	"GROUPP",                	/* 0x41 */
-	"LONGJMP",               	/* 0x42 */
-	"BRANCHJ",               	/* 0x43 */
-	"EVAL",                  	/* 0x44 */
-	"MINMOD",                	/* 0x45 */
-	"LOGICAL",               	/* 0x46 */
-	"RENUM",                 	/* 0x47 */
-	"TRIE",                  	/* 0x48 */
-	"TRIEC",                 	/* 0x49 */
-	"AHOCORASICK",           	/* 0x4a */
-	"AHOCORASICKC",          	/* 0x4b */
-	"GOSUB",                 	/* 0x4c */
-	"GOSTART",               	/* 0x4d */
-	"NGROUPP",               	/* 0x4e */
-	"INSUBP",                	/* 0x4f */
-	"DEFINEP",               	/* 0x50 */
-	"ENDLIKE",               	/* 0x51 */
-	"OPFAIL",                	/* 0x52 */
-	"ACCEPT",                	/* 0x53 */
-	"VERB",                  	/* 0x54 */
-	"PRUNE",                 	/* 0x55 */
-	"MARKPOINT",             	/* 0x56 */
-	"SKIP",                  	/* 0x57 */
-	"COMMIT",                	/* 0x58 */
-	"CUTGROUP",              	/* 0x59 */
-	"KEEPS",                 	/* 0x5a */
-	"LNBREAK",               	/* 0x5b */
-	"OPTIMIZED",             	/* 0x5c */
-	"PSEUDO",                	/* 0x5d */
+	"ANYOF_NON_UTF8_NON_ASCII_ALL",	/* 0x16 */
+	"POSIXD",                	/* 0x17 */
+	"POSIXL",                	/* 0x18 */
+	"POSIXU",                	/* 0x19 */
+	"POSIXA",                	/* 0x1a */
+	"NPOSIXD",               	/* 0x1b */
+	"NPOSIXL",               	/* 0x1c */
+	"NPOSIXU",               	/* 0x1d */
+	"NPOSIXA",               	/* 0x1e */
+	"CLUMP",                 	/* 0x1f */
+	"BRANCH",                	/* 0x20 */
+	"BACK",                  	/* 0x21 */
+	"EXACT",                 	/* 0x22 */
+	"EXACTF",                	/* 0x23 */
+	"EXACTFL",               	/* 0x24 */
+	"EXACTFU",               	/* 0x25 */
+	"EXACTFA",               	/* 0x26 */
+	"EXACTFU_SS",            	/* 0x27 */
+	"EXACTFA_NO_TRIE",       	/* 0x28 */
+	"NOTHING",               	/* 0x29 */
+	"TAIL",                  	/* 0x2a */
+	"STAR",                  	/* 0x2b */
+	"PLUS",                  	/* 0x2c */
+	"CURLY",                 	/* 0x2d */
+	"CURLYN",                	/* 0x2e */
+	"CURLYM",                	/* 0x2f */
+	"CURLYX",                	/* 0x30 */
+	"WHILEM",                	/* 0x31 */
+	"OPEN",                  	/* 0x32 */
+	"CLOSE",                 	/* 0x33 */
+	"REF",                   	/* 0x34 */
+	"REFF",                  	/* 0x35 */
+	"REFFL",                 	/* 0x36 */
+	"REFFU",                 	/* 0x37 */
+	"REFFA",                 	/* 0x38 */
+	"NREF",                  	/* 0x39 */
+	"NREFF",                 	/* 0x3a */
+	"NREFFL",                	/* 0x3b */
+	"NREFFU",                	/* 0x3c */
+	"NREFFA",                	/* 0x3d */
+	"IFMATCH",               	/* 0x3e */
+	"UNLESSM",               	/* 0x3f */
+	"SUSPEND",               	/* 0x40 */
+	"IFTHEN",                	/* 0x41 */
+	"GROUPP",                	/* 0x42 */
+	"LONGJMP",               	/* 0x43 */
+	"BRANCHJ",               	/* 0x44 */
+	"EVAL",                  	/* 0x45 */
+	"MINMOD",                	/* 0x46 */
+	"LOGICAL",               	/* 0x47 */
+	"RENUM",                 	/* 0x48 */
+	"TRIE",                  	/* 0x49 */
+	"TRIEC",                 	/* 0x4a */
+	"AHOCORASICK",           	/* 0x4b */
+	"AHOCORASICKC",          	/* 0x4c */
+	"GOSUB",                 	/* 0x4d */
+	"GOSTART",               	/* 0x4e */
+	"NGROUPP",               	/* 0x4f */
+	"INSUBP",                	/* 0x50 */
+	"DEFINEP",               	/* 0x51 */
+	"ENDLIKE",               	/* 0x52 */
+	"OPFAIL",                	/* 0x53 */
+	"ACCEPT",                	/* 0x54 */
+	"VERB",                  	/* 0x55 */
+	"PRUNE",                 	/* 0x56 */
+	"MARKPOINT",             	/* 0x57 */
+	"SKIP",                  	/* 0x58 */
+	"COMMIT",                	/* 0x59 */
+	"CUTGROUP",              	/* 0x5a */
+	"KEEPS",                 	/* 0x5b */
+	"LNBREAK",               	/* 0x5c */
+	"OPTIMIZED",             	/* 0x5d */
+	"PSEUDO",                	/* 0x5e */
 	/* ------------ States ------------- */
 	"TRIE_next",             	/* REGNODE_MAX +0x01 */
 	"TRIE_next_fail",        	/* REGNODE_MAX +0x02 */
@@ -717,7 +722,7 @@ EXTCONST U8 PL_varies[] __attribute__deprecated__ = {
 EXTCONST U8 PL_varies_bitmask[];
 #else
 EXTCONST U8 PL_varies_bitmask[] = {
-    0x00, 0x00, 0x00, 0xC0, 0x01, 0xFC, 0xF9, 0x9F, 0x09, 0x00, 0x00, 0x00
+    0x00, 0x00, 0x00, 0x80, 0x03, 0xF8, 0xF3, 0x3F, 0x13, 0x00, 0x00, 0x00
 };
 #endif /* DOINIT */
 
@@ -729,8 +734,8 @@ EXTCONST U8 PL_varies_bitmask[] = {
 EXTCONST U8 PL_simple[] __attribute__deprecated__;
 #else
 EXTCONST U8 PL_simple[] __attribute__deprecated__ = {
-    REG_ANY, SANY, CANY, ANYOF, POSIXD, POSIXL, POSIXU, POSIXA, NPOSIXD,
-    NPOSIXL, NPOSIXU, NPOSIXA,
+    REG_ANY, SANY, CANY, ANYOF, ANYOF_NON_UTF8_NON_ASCII_ALL, POSIXD,
+    POSIXL, POSIXU, POSIXA, NPOSIXD, NPOSIXL, NPOSIXU, NPOSIXA,
     0
 };
 #endif /* DOINIT */
@@ -739,7 +744,7 @@ EXTCONST U8 PL_simple[] __attribute__deprecated__ = {
 EXTCONST U8 PL_simple_bitmask[];
 #else
 EXTCONST U8 PL_simple_bitmask[] = {
-    0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
 #endif /* DOINIT */