Add new regnode for synthetic start class

This creates a regnode specifically for the synthetic start class, which
is a type of ANYOF node.  The flag bit previously used to denote this is
removed.  This paves the way for this bit to be freed up, but first the
other use of this bit must also be removed, which will be done in the
next commit.

There are now three ANYOF-type regnodes.  This one should be called only
in one place in regexec.c.  The other special one is ANYOF_WARN_SUPER.
A synthetic start class node should not do any warning, so there is no
issue of having something need to be both types.

6 files changed, 162 insertions, 164 deletions

diff --git a/pod/perldebguts.pod b/pod/perldebguts.pod
index 2d413e4612..a17a6b4aa3 100644
--- a/pod/perldebguts.pod
+++ b/pod/perldebguts.pod
@@ -583,6 +583,7 @@ will be lost.
  ANYOF_WARN_SUPER   sv         Match character in (or not in) this
                                class, warn (if enabled) upon matching a
                                char above Unicode max;
+ ANYOF_SYNTHETIC    sv         Synthetic start class
 
  POSIXD             none       Some [[:class:]] under /d; the FLAGS
                                field gives which one
diff --git a/regcomp.c b/regcomp.c
index 44fddcccee..b24adae8e2 100644
--- a/regcomp.c
+++ b/regcomp.c
@@ -6152,7 +6152,7 @@ reStudy:
 	    && !cl_is_anything(data.start_class))
 	{
 	    const U32 n = add_data(pRExC_state, 1, "f");
-	    data.start_class->flags |= ANYOF_IS_SYNTHETIC;
+	    OP(data.start_class) = ANYOF_SYNTHETIC;
 
 	    Newx(RExC_rxi->data->data[n], 1,
 		struct regnode_charclass_class);
@@ -6224,7 +6224,7 @@ reStudy:
 	    && !cl_is_anything(data.start_class))
 	{
 	    const U32 n = add_data(pRExC_state, 1, "f");
-	    data.start_class->flags |= ANYOF_IS_SYNTHETIC;
+	    OP(data.start_class) = ANYOF_SYNTHETIC;
 
 	    Newx(RExC_rxi->data->data[n], 1,
 		struct regnode_charclass_class);
diff --git a/regcomp.h b/regcomp.h
index d7b7665e1b..1137d67872 100644
--- a/regcomp.h
+++ b/regcomp.h
@@ -319,8 +319,7 @@ struct regnode_charclass_class {
  * to match everything above.  If flags need to be added that are applicable to
  * the synthetic start class only, with some work, they could be put in the
  * next-node field, or in an unused bit of the classflags field.  This could be
- * done with the current EOS flag, and a new node type created that is just for
- * the ssc, freeing up that bit */
+ * done with the current EOS flag, freeing up that bit */
 
 #define ANYOF_LOCALE		 0x01	    /* /l modifier */
 
@@ -344,15 +343,6 @@ struct regnode_charclass_class {
  * synthetic start class only. */
 #define ANYOF_EOS		0x10
 
-/* ? Is this node the synthetic start class (ssc).  This bit is shared with
- * ANYOF_EOS, as the latter is used only for the ssc, and then not used by
- * regexec.c.  And, the code is structured so that if it is set, the ssc is
- * not used, so it is guaranteed to be 0 for the ssc by the time regexec.c
- * gets executed, and 0 for a non-ssc ANYOF node, as it only ever gets set for
- * a potential ssc candidate.  Thus setting it to 1 after it has been
- * determined that the ssc will be used is not ambiguous */
-#define ANYOF_IS_SYNTHETIC	ANYOF_EOS
-
 /* Can match something outside the bitmap that isn't in utf8 */
 #define ANYOF_NONBITMAP_NON_UTF8 0x20
 
diff --git a/regcomp.sym b/regcomp.sym
index 68182c9e34..4de5d79bf5 100644
--- a/regcomp.sym
+++ b/regcomp.sym
@@ -56,6 +56,7 @@ SANY        REG_ANY,    no 0 S    ; Match any one character.
 CANY        REG_ANY,    no 0 S    ; Match any one byte.
 ANYOF       ANYOF,      sv 0 S    ; Match character in (or not in) this class, single char match only
 ANYOF_WARN_SUPER ANYOF, sv 0 S    ; Match character in (or not in) this class, warn (if enabled) upon matching a char above Unicode max;
+ANYOF_SYNTHETIC ANYOF,  sv 0 S    ; Synthetic start class
 
 # Order of the below is important.  See ordering comment above.
 POSIXD      POSIXD,     none 0 S   ; Some [[:class:]] under /d; the FLAGS field gives which one
diff --git a/regexec.c b/regexec.c
index 1b373941b9..8576e3b536 100644
--- a/regexec.c
+++ b/regexec.c
@@ -1457,6 +1457,7 @@ S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s,
     /* We know what class it must start with. */
     switch (OP(c)) {
     case ANYOF:
+    case ANYOF_SYNTHETIC:
     case ANYOF_WARN_SUPER:
         if (utf8_target) {
             REXEC_FBC_UTF8_CLASS_SCAN(
@@ -7365,7 +7366,7 @@ S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8* const
 		     || (utf8_target
 		         && (c >=256
 			     || (! (flags & ANYOF_LOCALE))
-			     || (flags & ANYOF_IS_SYNTHETIC)))))
+			     || OP(n) == ANYOF_SYNTHETIC))))
 	{
 	    SV * const sw = core_regclass_swash(prog, n, TRUE, 0);
 	    if (sw) {
diff --git a/regnodes.h b/regnodes.h
index d1d3cab787..433460deea 100644
--- a/regnodes.h
+++ b/regnodes.h
@@ -6,8 +6,8 @@
 
 /* Regops and State definitions */
 
-#define REGNODE_MAX           	94
-#define REGMATCH_STATE_MAX    	134
+#define REGNODE_MAX           	95
+#define REGMATCH_STATE_MAX    	135
 
 #define	END                   	0	/* 0000 End of program. */
 #define	SUCCEED               	1	/* 0x01 Return from a subroutine, basically. */
@@ -32,78 +32,79 @@
 #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	ANYOF_WARN_SUPER      	22	/* 0x16 Match character in (or not in) this class, warn (if enabled) upon matching a char above Unicode max; */
-#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	EXACTFU_TRICKYFOLD    	40	/* 0x28 Match this folded UTF-8 string using /iu rules */
-#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. */
+#define	ANYOF_SYNTHETIC       	23	/* 0x17 Synthetic start class */
+#define	POSIXD                	24	/* 0x18 Some [[:class:]] under /d; the FLAGS field gives which one */
+#define	POSIXL                	25	/* 0x19 Some [[:class:]] under /l; the FLAGS field gives which one */
+#define	POSIXU                	26	/* 0x1a Some [[:class:]] under /u; the FLAGS field gives which one */
+#define	POSIXA                	27	/* 0x1b Some [[:class:]] under /a; the FLAGS field gives which one */
+#define	NPOSIXD               	28	/* 0x1c complement of POSIXD, [[:^class:]] */
+#define	NPOSIXL               	29	/* 0x1d complement of POSIXL, [[:^class:]] */
+#define	NPOSIXU               	30	/* 0x1e complement of POSIXU, [[:^class:]] */
+#define	NPOSIXA               	31	/* 0x1f complement of POSIXA, [[:^class:]] */
+#define	CLUMP                 	32	/* 0x20 Match any extended grapheme cluster sequence */
+#define	BRANCH                	33	/* 0x21 Match this alternative, or the next... */
+#define	BACK                  	34	/* 0x22 Match "", "next" ptr points backward. */
+#define	EXACT                 	35	/* 0x23 Match this string (preceded by length). */
+#define	EXACTF                	36	/* 0x24 Match this non-UTF-8 string (not guaranteed to be folded) using /id rules (w/len). */
+#define	EXACTFL               	37	/* 0x25 Match this string (not guaranteed to be folded) using /il rules (w/len). */
+#define	EXACTFU               	38	/* 0x26 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               	39	/* 0x27 Match this string (not guaranteed to be folded) using /iaa rules (w/len). */
+#define	EXACTFU_SS            	40	/* 0x28 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	EXACTFU_TRICKYFOLD    	41	/* 0x29 Match this folded UTF-8 string using /iu rules */
+#define	NOTHING               	42	/* 0x2a Match empty string. */
+#define	TAIL                  	43	/* 0x2b Match empty string. Can jump here from outside. */
+#define	STAR                  	44	/* 0x2c Match this (simple) thing 0 or more times. */
+#define	PLUS                  	45	/* 0x2d Match this (simple) thing 1 or more times. */
+#define	CURLY                 	46	/* 0x2e Match this simple thing {n,m} times. */
+#define	CURLYN                	47	/* 0x2f Capture next-after-this simple thing */
+#define	CURLYM                	48	/* 0x30 Capture this medium-complex thing {n,m} times. */
+#define	CURLYX                	49	/* 0x31 Match this complex thing {n,m} times. */
+#define	WHILEM                	50	/* 0x32 Do curly processing and see if rest matches. */
+#define	OPEN                  	51	/* 0x33 Mark this point in input as start of #n. */
+#define	CLOSE                 	52	/* 0x34 Analogous to OPEN. */
+#define	REF                   	53	/* 0x35 Match some already matched string */
+#define	REFF                  	54	/* 0x36 Match already matched string, folded using native charset semantics for non-utf8 */
+#define	REFFL                 	55	/* 0x37 Match already matched string, folded in loc. */
+#define	REFFU                 	56	/* 0x38 Match already matched string, folded using unicode semantics for non-utf8 */
+#define	REFFA                 	57	/* 0x39 Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */
+#define	NREF                  	58	/* 0x3a Match some already matched string */
+#define	NREFF                 	59	/* 0x3b Match already matched string, folded using native charset semantics for non-utf8 */
+#define	NREFFL                	60	/* 0x3c Match already matched string, folded in loc. */
+#define	NREFFU                	61	/* 0x3d Match already matched string, folded using unicode semantics for non-utf8 */
+#define	NREFFA                	62	/* 0x3e Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */
+#define	IFMATCH               	63	/* 0x3f Succeeds if the following matches. */
+#define	UNLESSM               	64	/* 0x40 Fails if the following matches. */
+#define	SUSPEND               	65	/* 0x41 "Independent" sub-RE. */
+#define	IFTHEN                	66	/* 0x42 Switch, should be preceded by switcher. */
+#define	GROUPP                	67	/* 0x43 Whether the group matched. */
+#define	LONGJMP               	68	/* 0x44 Jump far away. */
+#define	BRANCHJ               	69	/* 0x45 BRANCH with long offset. */
+#define	EVAL                  	70	/* 0x46 Execute some Perl code. */
+#define	MINMOD                	71	/* 0x47 Next operator is not greedy. */
+#define	LOGICAL               	72	/* 0x48 Next opcode should set the flag only. */
+#define	RENUM                 	73	/* 0x49 Group with independently numbered parens. */
+#define	TRIE                  	74	/* 0x4a Match many EXACT(F[ALU]?)? at once. flags==type */
+#define	TRIEC                 	75	/* 0x4b Same as TRIE, but with embedded charclass data */
+#define	AHOCORASICK           	76	/* 0x4c Aho Corasick stclass. flags==type */
+#define	AHOCORASICKC          	77	/* 0x4d Same as AHOCORASICK, but with embedded charclass data */
+#define	GOSUB                 	78	/* 0x4e recurse to paren arg1 at (signed) ofs arg2 */
+#define	GOSTART               	79	/* 0x4f recurse to start of pattern */
+#define	NGROUPP               	80	/* 0x50 Whether the group matched. */
+#define	INSUBP                	81	/* 0x51 Whether we are in a specific recurse. */
+#define	DEFINEP               	82	/* 0x52 Never execute directly. */
+#define	ENDLIKE               	83	/* 0x53 Used only for the type field of verbs */
+#define	OPFAIL                	84	/* 0x54 Same as (?!) */
+#define	ACCEPT                	85	/* 0x55 Accepts the current matched string. */
+#define	VERB                  	86	/* 0x56 Used only for the type field of verbs */
+#define	PRUNE                 	87	/* 0x57 Pattern fails at this startpoint if no-backtracking through this */
+#define	MARKPOINT             	88	/* 0x58 Push the current location for rollback by cut. */
+#define	SKIP                  	89	/* 0x59 On failure skip forward (to the mark) before retrying */
+#define	COMMIT                	90	/* 0x5a Pattern fails outright if backtracking through this */
+#define	CUTGROUP              	91	/* 0x5b On failure go to the next alternation in the group */
+#define	KEEPS                 	92	/* 0x5c $& begins here. */
+#define	LNBREAK               	93	/* 0x5d generic newline pattern */
+#define	OPTIMIZED             	94	/* 0x5e Placeholder for dump. */
+#define	PSEUDO                	95	/* 0x5f 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 */
@@ -175,6 +176,7 @@ EXTCONST U8 PL_regkind[] = {
 	REG_ANY,  	/* CANY                   */
 	ANYOF,    	/* ANYOF                  */
 	ANYOF,    	/* ANYOF_WARN_SUPER       */
+	ANYOF,    	/* ANYOF_SYNTHETIC        */
 	POSIXD,   	/* POSIXD                 */
 	POSIXD,   	/* POSIXL                 */
 	POSIXD,   	/* POSIXU                 */
@@ -318,6 +320,7 @@ static const U8 regarglen[] = {
 	0,                                   	/* CANY         */
 	0,                                   	/* ANYOF        */
 	0,                                   	/* ANYOF_WARN_SUPER */
+	0,                                   	/* ANYOF_SYNTHETIC */
 	0,                                   	/* POSIXD       */
 	0,                                   	/* POSIXL       */
 	0,                                   	/* POSIXU       */
@@ -418,6 +421,7 @@ static const char reg_off_by_arg[] = {
 	0,	/* CANY         */
 	0,	/* ANYOF        */
 	0,	/* ANYOF_WARN_SUPER */
+	0,	/* ANYOF_SYNTHETIC */
 	0,	/* POSIXD       */
 	0,	/* POSIXL       */
 	0,	/* POSIXU       */
@@ -523,78 +527,79 @@ EXTCONST char * const PL_reg_name[] = {
 	"CANY",                  	/* 0x14 */
 	"ANYOF",                 	/* 0x15 */
 	"ANYOF_WARN_SUPER",      	/* 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 */
-	"EXACTFU_TRICKYFOLD",    	/* 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 */
+	"ANYOF_SYNTHETIC",       	/* 0x17 */
+	"POSIXD",                	/* 0x18 */
+	"POSIXL",                	/* 0x19 */
+	"POSIXU",                	/* 0x1a */
+	"POSIXA",                	/* 0x1b */
+	"NPOSIXD",               	/* 0x1c */
+	"NPOSIXL",               	/* 0x1d */
+	"NPOSIXU",               	/* 0x1e */
+	"NPOSIXA",               	/* 0x1f */
+	"CLUMP",                 	/* 0x20 */
+	"BRANCH",                	/* 0x21 */
+	"BACK",                  	/* 0x22 */
+	"EXACT",                 	/* 0x23 */
+	"EXACTF",                	/* 0x24 */
+	"EXACTFL",               	/* 0x25 */
+	"EXACTFU",               	/* 0x26 */
+	"EXACTFA",               	/* 0x27 */
+	"EXACTFU_SS",            	/* 0x28 */
+	"EXACTFU_TRICKYFOLD",    	/* 0x29 */
+	"NOTHING",               	/* 0x2a */
+	"TAIL",                  	/* 0x2b */
+	"STAR",                  	/* 0x2c */
+	"PLUS",                  	/* 0x2d */
+	"CURLY",                 	/* 0x2e */
+	"CURLYN",                	/* 0x2f */
+	"CURLYM",                	/* 0x30 */
+	"CURLYX",                	/* 0x31 */
+	"WHILEM",                	/* 0x32 */
+	"OPEN",                  	/* 0x33 */
+	"CLOSE",                 	/* 0x34 */
+	"REF",                   	/* 0x35 */
+	"REFF",                  	/* 0x36 */
+	"REFFL",                 	/* 0x37 */
+	"REFFU",                 	/* 0x38 */
+	"REFFA",                 	/* 0x39 */
+	"NREF",                  	/* 0x3a */
+	"NREFF",                 	/* 0x3b */
+	"NREFFL",                	/* 0x3c */
+	"NREFFU",                	/* 0x3d */
+	"NREFFA",                	/* 0x3e */
+	"IFMATCH",               	/* 0x3f */
+	"UNLESSM",               	/* 0x40 */
+	"SUSPEND",               	/* 0x41 */
+	"IFTHEN",                	/* 0x42 */
+	"GROUPP",                	/* 0x43 */
+	"LONGJMP",               	/* 0x44 */
+	"BRANCHJ",               	/* 0x45 */
+	"EVAL",                  	/* 0x46 */
+	"MINMOD",                	/* 0x47 */
+	"LOGICAL",               	/* 0x48 */
+	"RENUM",                 	/* 0x49 */
+	"TRIE",                  	/* 0x4a */
+	"TRIEC",                 	/* 0x4b */
+	"AHOCORASICK",           	/* 0x4c */
+	"AHOCORASICKC",          	/* 0x4d */
+	"GOSUB",                 	/* 0x4e */
+	"GOSTART",               	/* 0x4f */
+	"NGROUPP",               	/* 0x50 */
+	"INSUBP",                	/* 0x51 */
+	"DEFINEP",               	/* 0x52 */
+	"ENDLIKE",               	/* 0x53 */
+	"OPFAIL",                	/* 0x54 */
+	"ACCEPT",                	/* 0x55 */
+	"VERB",                  	/* 0x56 */
+	"PRUNE",                 	/* 0x57 */
+	"MARKPOINT",             	/* 0x58 */
+	"SKIP",                  	/* 0x59 */
+	"COMMIT",                	/* 0x5a */
+	"CUTGROUP",              	/* 0x5b */
+	"KEEPS",                 	/* 0x5c */
+	"LNBREAK",               	/* 0x5d */
+	"OPTIMIZED",             	/* 0x5e */
+	"PSEUDO",                	/* 0x5f */
 	/* ------------ States ------------- */
 	"TRIE_next",             	/* REGNODE_MAX +0x01 */
 	"TRIE_next_fail",        	/* REGNODE_MAX +0x02 */
@@ -699,7 +704,7 @@ EXTCONST U8 PL_varies[] __attribute__deprecated__ = {
 EXTCONST U8 PL_varies_bitmask[];
 #else
 EXTCONST U8 PL_varies_bitmask[] = {
-    0x00, 0x00, 0x00, 0x80, 0x03, 0xF8, 0xF3, 0x3F, 0x13, 0x00, 0x00, 0x00
+    0x00, 0x00, 0x00, 0x00, 0x07, 0xF0, 0xE7, 0x7F, 0x26, 0x00, 0x00, 0x00
 };
 #endif /* DOINIT */
 
@@ -711,8 +716,8 @@ EXTCONST U8 PL_varies_bitmask[] = {
 EXTCONST U8 PL_simple[] __attribute__deprecated__;
 #else
 EXTCONST U8 PL_simple[] __attribute__deprecated__ = {
-    REG_ANY, SANY, CANY, ANYOF, ANYOF_WARN_SUPER, POSIXD, POSIXL, POSIXU,
-    POSIXA, NPOSIXD, NPOSIXL, NPOSIXU, NPOSIXA,
+    REG_ANY, SANY, CANY, ANYOF, ANYOF_WARN_SUPER, ANYOF_SYNTHETIC, POSIXD,
+    POSIXL, POSIXU, POSIXA, NPOSIXD, NPOSIXL, NPOSIXU, NPOSIXA,
     0
 };
 #endif /* DOINIT */
@@ -721,7 +726,7 @@ EXTCONST U8 PL_simple[] __attribute__deprecated__ = {
 EXTCONST U8 PL_simple_bitmask[];
 #else
 EXTCONST U8 PL_simple_bitmask[] = {
-    0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    0x00, 0x00, 0xFC, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
 #endif /* DOINIT */