Automate generation of the regmatch() state constants

Subject:  Re: Problem with EVAL handling in bleads iterative regex code.
Message-Id:  <9b18b3110609251109t4cb1d443y87d7a7dc94fcfc24@mail.gmail.com>

p4raw-id: //depot/perl@28892

1 files changed, 424 insertions, 340 deletions

diff --git a/regnodes.h b/regnodes.h
index 01985f5a73..b967287a95 100644
--- a/regnodes.h
+++ b/regnodes.h
@@ -4,365 +4,449 @@
    Any changes made here will be lost!
 */
 
-#define	END	0	/*    0 End of program. */
-#define	SUCCEED	1	/*  0x1 Return from a subroutine, basically. */
-#define	BOL	2	/*  0x2 Match "" at beginning of line. */
-#define	MBOL	3	/*  0x3 Same, assuming multiline. */
-#define	SBOL	4	/*  0x4 Same, assuming singleline. */
-#define	EOS	5	/*  0x5 Match "" at end of string. */
-#define	EOL	6	/*  0x6 Match "" at end of line. */
-#define	MEOL	7	/*  0x7 Same, assuming multiline. */
-#define	SEOL	8	/*  0x8 Same, assuming singleline. */
-#define	BOUND	9	/*  0x9 Match "" at any word boundary */
-#define	BOUNDL	10	/*  0xa Match "" at any word boundary */
-#define	NBOUND	11	/*  0xb Match "" at any word non-boundary */
-#define	NBOUNDL	12	/*  0xc Match "" at any word non-boundary */
-#define	GPOS	13	/*  0xd Matches where last m//g left off. */
-#define	REG_ANY	14	/*  0xe Match any one character (except newline). */
-#define	SANY	15	/*  0xf Match any one character. */
-#define	CANY	16	/* 0x10 Match any one byte. */
-#define	ANYOF	17	/* 0x11 Match character in (or not in) this class. */
-#define	ALNUM	18	/* 0x12 Match any alphanumeric character */
-#define	ALNUML	19	/* 0x13 Match any alphanumeric char in locale */
-#define	NALNUM	20	/* 0x14 Match any non-alphanumeric character */
-#define	NALNUML	21	/* 0x15 Match any non-alphanumeric char in locale */
-#define	SPACE	22	/* 0x16 Match any whitespace character */
-#define	SPACEL	23	/* 0x17 Match any whitespace char in locale */
-#define	NSPACE	24	/* 0x18 Match any non-whitespace character */
-#define	NSPACEL	25	/* 0x19 Match any non-whitespace char in locale */
-#define	DIGIT	26	/* 0x1a Match any numeric character */
-#define	DIGITL	27	/* 0x1b Match any numeric character in locale */
-#define	NDIGIT	28	/* 0x1c Match any non-numeric character */
-#define	NDIGITL	29	/* 0x1d Match any non-numeric character in locale */
-#define	CLUMP	30	/* 0x1e Match any combining character 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 string, folded (prec. by length). */
-#define	EXACTFL	35	/* 0x23 Match this string, folded in locale (w/len). */
-#define	NOTHING	36	/* 0x24 Match empty string. */
-#define	TAIL	37	/* 0x25 Match empty string. Can jump here from outside. */
-#define	STAR	38	/* 0x26 Match this (simple) thing 0 or more times. */
-#define	PLUS	39	/* 0x27 Match this (simple) thing 1 or more times. */
-#define	CURLY	40	/* 0x28 Match this simple thing {n,m} times. */
-#define	CURLYN	41	/* 0x29 Match next-after-this simple thing  */
-#define	CURLYM	42	/* 0x2a Match this medium-complex thing {n,m} times. */
-#define	CURLYX	43	/* 0x2b Match this complex thing {n,m} times. */
-#define	WHILEM	44	/* 0x2c Do curly processing and see if rest matches. */
-#define	OPEN	45	/* 0x2d Mark this point in input as start of #n. */
-#define	CLOSE	46	/* 0x2e Analogous to OPEN. */
-#define	REF	47	/* 0x2f Match some already matched string */
-#define	REFF	48	/* 0x30 Match already matched string, folded */
-#define	REFFL	49	/* 0x31 Match already matched string, folded in loc. */
-#define	IFMATCH	50	/* 0x32 Succeeds if the following matches. */
-#define	UNLESSM	51	/* 0x33 Fails if the following matches. */
-#define	SUSPEND	52	/* 0x34 "Independent" sub-RE. */
-#define	IFTHEN	53	/* 0x35 Switch, should be preceeded by switcher . */
-#define	GROUPP	54	/* 0x36 Whether the group matched. */
-#define	LONGJMP	55	/* 0x37 Jump far away. */
-#define	BRANCHJ	56	/* 0x38 BRANCH with long offset. */
-#define	EVAL	57	/* 0x39 Execute some Perl code. */
-#define	MINMOD	58	/* 0x3a Next operator is not greedy. */
-#define	LOGICAL	59	/* 0x3b Next opcode should set the flag only. */
-#define	RENUM	60	/* 0x3c Group with independently numbered parens. */
-#define	TRIE	61	/* 0x3d Match many EXACT(FL?)? at once. flags==type */
-#define	TRIEC	62	/* 0x3e Same as TRIE, but with embedded charclass data */
-#define	AHOCORASICK	63	/* 0x3f Aho Corasick stclass. flags==type */
-#define	AHOCORASICKC	64	/* 0x40 Same as AHOCORASICK, but with embedded charclass data */
-#define	OPTIMIZED	65	/* 0x41 Placeholder for dump. */
-#define	PSEUDO	66	/* 0x42 Pseudo opcode for internal use. */
-#define REGNODE_MAX 66
+#define REGNODE_MAX           	66
+#define REGMATCH_STATE_MAX    	91
+
+#define	END                   	0	/*0000 End of program.*/
+#define	SUCCEED               	1	/*0x01 Return from a subroutine, basically.*/
+#define	BOL                   	2	/*0x02 Match "" at beginning of line.*/
+#define	MBOL                  	3	/*0x03 Same, assuming multiline.*/
+#define	SBOL                  	4	/*0x04 Same, assuming singleline.*/
+#define	EOS                   	5	/*0x05 Match "" at end of string.*/
+#define	EOL                   	6	/*0x06 Match "" at end of line.*/
+#define	MEOL                  	7	/*0x07 Same, assuming multiline.*/
+#define	SEOL                  	8	/*0x08 Same, assuming singleline.*/
+#define	BOUND                 	9	/*0x09 Match "" at any word boundary*/
+#define	BOUNDL                	10	/*0x0a Match "" at any word boundary*/
+#define	NBOUND                	11	/*0x0b Match "" at any word non-boundary*/
+#define	NBOUNDL               	12	/*0x0c Match "" at any word non-boundary*/
+#define	GPOS                  	13	/*0x0d Matches where last m//g left off.*/
+#define	REG_ANY               	14	/*0x0e Match any one character (except newline).*/
+#define	SANY                  	15	/*0x0f Match any one character.*/
+#define	CANY                  	16	/*0x10 Match any one byte.*/
+#define	ANYOF                 	17	/*0x11 Match character in (or not in) this class.*/
+#define	ALNUM                 	18	/*0x12 Match any alphanumeric character*/
+#define	ALNUML                	19	/*0x13 Match any alphanumeric char in locale*/
+#define	NALNUM                	20	/*0x14 Match any non-alphanumeric character*/
+#define	NALNUML               	21	/*0x15 Match any non-alphanumeric char in locale*/
+#define	SPACE                 	22	/*0x16 Match any whitespace character*/
+#define	SPACEL                	23	/*0x17 Match any whitespace char in locale*/
+#define	NSPACE                	24	/*0x18 Match any non-whitespace character*/
+#define	NSPACEL               	25	/*0x19 Match any non-whitespace char in locale*/
+#define	DIGIT                 	26	/*0x1a Match any numeric character*/
+#define	DIGITL                	27	/*0x1b Match any numeric character in locale*/
+#define	NDIGIT                	28	/*0x1c Match any non-numeric character*/
+#define	NDIGITL               	29	/*0x1d Match any non-numeric character in locale*/
+#define	CLUMP                 	30	/*0x1e Match any combining character 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 string, folded (prec. by length).*/
+#define	EXACTFL               	35	/*0x23 Match this string, folded in locale (w/len).*/
+#define	NOTHING               	36	/*0x24 Match empty string.*/
+#define	TAIL                  	37	/*0x25 Match empty string. Can jump here from outside.*/
+#define	STAR                  	38	/*0x26 Match this (simple) thing 0 or more times.*/
+#define	PLUS                  	39	/*0x27 Match this (simple) thing 1 or more times.*/
+#define	CURLY                 	40	/*0x28 Match this simple thing {n,m} times.*/
+#define	CURLYN                	41	/*0x29 Match next-after-this simple thing*/
+#define	CURLYM                	42	/*0x2a Match this medium-complex thing {n,m} times.*/
+#define	CURLYX                	43	/*0x2b Match this complex thing {n,m} times.*/
+#define	WHILEM                	44	/*0x2c Do curly processing and see if rest matches.*/
+#define	OPEN                  	45	/*0x2d Mark this point in input as start of*/
+#define	CLOSE                 	46	/*0x2e Analogous to OPEN.*/
+#define	REF                   	47	/*0x2f Match some already matched string*/
+#define	REFF                  	48	/*0x30 Match already matched string, folded*/
+#define	REFFL                 	49	/*0x31 Match already matched string, folded in loc.*/
+#define	IFMATCH               	50	/*0x32 Succeeds if the following matches.*/
+#define	UNLESSM               	51	/*0x33 Fails if the following matches.*/
+#define	SUSPEND               	52	/*0x34 "Independent" sub-RE.*/
+#define	IFTHEN                	53	/*0x35 Switch, should be preceeded by switcher .*/
+#define	GROUPP                	54	/*0x36 Whether the group matched.*/
+#define	LONGJMP               	55	/*0x37 Jump far away.*/
+#define	BRANCHJ               	56	/*0x38 BRANCH with long offset.*/
+#define	EVAL                  	57	/*0x39 Execute some Perl code.*/
+#define	MINMOD                	58	/*0x3a Next operator is not greedy.*/
+#define	LOGICAL               	59	/*0x3b Next opcode should set the flag only.*/
+#define	RENUM                 	60	/*0x3c Group with independently numbered parens.*/
+#define	TRIE                  	61	/*0x3d Match many EXACT(FL?)? at once. flags==type*/
+#define	TRIEC                 	62	/*0x3e Same as TRIE, but with embedded charclass data*/
+#define	AHOCORASICK           	63	/*0x3f Aho Corasick stclass. flags==type*/
+#define	AHOCORASICKC          	64	/*0x40 Same as AHOCORASICK, but with embedded charclass data*/
+#define	OPTIMIZED             	65	/*0x41 Placeholder for dump.*/
+#define	PSEUDO                	66	/*0x42 Pseudo opcode for internal use.*/
+
+	/* ------------ States ------------- */
+
+#define	TRIE_next             	67	/*0x43 Regmatch state for TRIE*/
+#define	TRIE_next_fail        	68	/*0x44 Regmatch state for TRIE*/
+#define	EVAL_AB               	69	/*0x45 Regmatch state for EVAL*/
+#define	EVAL_AB_fail          	70	/*0x46 Regmatch state for EVAL*/
+#define	resume_CURLYX         	71	/*0x47 Regmatch state for CURLYX*/
+#define	resume_WHILEM1        	72	/*0x48 Regmatch state for WHILEM*/
+#define	resume_WHILEM2        	73	/*0x49 Regmatch state for WHILEM*/
+#define	resume_WHILEM3        	74	/*0x4a Regmatch state for WHILEM*/
+#define	resume_WHILEM4        	75	/*0x4b Regmatch state for WHILEM*/
+#define	resume_WHILEM5        	76	/*0x4c Regmatch state for WHILEM*/
+#define	resume_WHILEM6        	77	/*0x4d Regmatch state for WHILEM*/
+#define	BRANCH_next           	78	/*0x4e Regmatch state for BRANCH*/
+#define	BRANCH_next_fail      	79	/*0x4f Regmatch state for BRANCH*/
+#define	CURLYM_A              	80	/*0x50 Regmatch state for CURLYM*/
+#define	CURLYM_A_fail         	81	/*0x51 Regmatch state for CURLYM*/
+#define	CURLYM_B              	82	/*0x52 Regmatch state for CURLYM*/
+#define	CURLYM_B_fail         	83	/*0x53 Regmatch state for CURLYM*/
+#define	IFMATCH_A             	84	/*0x54 Regmatch state for IFMATCH*/
+#define	IFMATCH_A_fail        	85	/*0x55 Regmatch state for IFMATCH*/
+#define	CURLY_B_min_known     	86	/*0x56 Regmatch state for CURLY*/
+#define	CURLY_B_min_known_fail	87	/*0x57 Regmatch state for CURLY*/
+#define	CURLY_B_min           	88	/*0x58 Regmatch state for CURLY*/
+#define	CURLY_B_min_fail      	89	/*0x59 Regmatch state for CURLY*/
+#define	CURLY_B_max           	90	/*0x5a Regmatch state for CURLY*/
+#define	CURLY_B_max_fail      	91	/*0x5b Regmatch state for CURLY*/
+
 
 #ifndef DOINIT
 EXTCONST U8 PL_regkind[];
 #else
 EXTCONST U8 PL_regkind[] = {
-	END,		/* END */
-	END,		/* SUCCEED */
-	BOL,		/* BOL */
-	BOL,		/* MBOL */
-	BOL,		/* SBOL */
-	EOL,		/* EOS */
-	EOL,		/* EOL */
-	EOL,		/* MEOL */
-	EOL,		/* SEOL */
-	BOUND,		/* BOUND */
-	BOUND,		/* BOUNDL */
-	NBOUND,		/* NBOUND */
-	NBOUND,		/* NBOUNDL */
-	GPOS,		/* GPOS */
-	REG_ANY,		/* REG_ANY */
-	REG_ANY,		/* SANY */
-	REG_ANY,		/* CANY */
-	ANYOF,		/* ANYOF */
-	ALNUM,		/* ALNUM */
-	ALNUM,		/* ALNUML */
-	NALNUM,		/* NALNUM */
-	NALNUM,		/* NALNUML */
-	SPACE,		/* SPACE */
-	SPACE,		/* SPACEL */
-	NSPACE,		/* NSPACE */
-	NSPACE,		/* NSPACEL */
-	DIGIT,		/* DIGIT */
-	DIGIT,		/* DIGITL */
-	NDIGIT,		/* NDIGIT */
-	NDIGIT,		/* NDIGITL */
-	CLUMP,		/* CLUMP */
-	BRANCH,		/* BRANCH */
-	BACK,		/* BACK */
-	EXACT,		/* EXACT */
-	EXACT,		/* EXACTF */
-	EXACT,		/* EXACTFL */
-	NOTHING,		/* NOTHING */
-	NOTHING,		/* TAIL */
-	STAR,		/* STAR */
-	PLUS,		/* PLUS */
-	CURLY,		/* CURLY */
-	CURLY,		/* CURLYN */
-	CURLY,		/* CURLYM */
-	CURLY,		/* CURLYX */
-	WHILEM,		/* WHILEM */
-	OPEN,		/* OPEN */
-	CLOSE,		/* CLOSE */
-	REF,		/* REF */
-	REF,		/* REFF */
-	REF,		/* REFFL */
-	BRANCHJ,		/* IFMATCH */
-	BRANCHJ,		/* UNLESSM */
-	BRANCHJ,		/* SUSPEND */
-	BRANCHJ,		/* IFTHEN */
-	GROUPP,		/* GROUPP */
-	LONGJMP,		/* LONGJMP */
-	BRANCHJ,		/* BRANCHJ */
-	EVAL,		/* EVAL */
-	MINMOD,		/* MINMOD */
-	LOGICAL,		/* LOGICAL */
-	BRANCHJ,		/* RENUM */
-	TRIE,		/* TRIE */
-	TRIE,		/* TRIEC */
-	TRIE,		/* AHOCORASICK */
-	TRIE,		/* AHOCORASICKC */
-	NOTHING,		/* OPTIMIZED */
-	PSEUDO,		/* PSEUDO */
+	END,    	/* END                    */
+	END,    	/* SUCCEED                */
+	BOL,    	/* BOL                    */
+	BOL,    	/* MBOL                   */
+	BOL,    	/* SBOL                   */
+	EOL,    	/* EOS                    */
+	EOL,    	/* EOL                    */
+	EOL,    	/* MEOL                   */
+	EOL,    	/* SEOL                   */
+	BOUND,  	/* BOUND                  */
+	BOUND,  	/* BOUNDL                 */
+	NBOUND, 	/* NBOUND                 */
+	NBOUND, 	/* NBOUNDL                */
+	GPOS,   	/* GPOS                   */
+	REG_ANY,	/* REG_ANY                */
+	REG_ANY,	/* SANY                   */
+	REG_ANY,	/* CANY                   */
+	ANYOF,  	/* ANYOF                  */
+	ALNUM,  	/* ALNUM                  */
+	ALNUM,  	/* ALNUML                 */
+	NALNUM, 	/* NALNUM                 */
+	NALNUM, 	/* NALNUML                */
+	SPACE,  	/* SPACE                  */
+	SPACE,  	/* SPACEL                 */
+	NSPACE, 	/* NSPACE                 */
+	NSPACE, 	/* NSPACEL                */
+	DIGIT,  	/* DIGIT                  */
+	DIGIT,  	/* DIGITL                 */
+	NDIGIT, 	/* NDIGIT                 */
+	NDIGIT, 	/* NDIGITL                */
+	CLUMP,  	/* CLUMP                  */
+	BRANCH, 	/* BRANCH                 */
+	BACK,   	/* BACK                   */
+	EXACT,  	/* EXACT                  */
+	EXACT,  	/* EXACTF                 */
+	EXACT,  	/* EXACTFL                */
+	NOTHING,	/* NOTHING                */
+	NOTHING,	/* TAIL                   */
+	STAR,   	/* STAR                   */
+	PLUS,   	/* PLUS                   */
+	CURLY,  	/* CURLY                  */
+	CURLY,  	/* CURLYN                 */
+	CURLY,  	/* CURLYM                 */
+	CURLY,  	/* CURLYX                 */
+	WHILEM, 	/* WHILEM                 */
+	OPEN,   	/* OPEN                   */
+	CLOSE,  	/* CLOSE                  */
+	REF,    	/* REF                    */
+	REF,    	/* REFF                   */
+	REF,    	/* REFFL                  */
+	BRANCHJ,	/* IFMATCH                */
+	BRANCHJ,	/* UNLESSM                */
+	BRANCHJ,	/* SUSPEND                */
+	BRANCHJ,	/* IFTHEN                 */
+	GROUPP, 	/* GROUPP                 */
+	LONGJMP,	/* LONGJMP                */
+	BRANCHJ,	/* BRANCHJ                */
+	EVAL,   	/* EVAL                   */
+	MINMOD, 	/* MINMOD                 */
+	LOGICAL,	/* LOGICAL                */
+	BRANCHJ,	/* RENUM                  */
+	TRIE,   	/* TRIE                   */
+	TRIE,   	/* TRIEC                  */
+	TRIE,   	/* AHOCORASICK            */
+	TRIE,   	/* AHOCORASICKC           */
+	NOTHING,	/* OPTIMIZED              */
+	PSEUDO, 	/* PSEUDO                 */
+	/* ------------ States ------------- */
+	TRIE,   	/* TRIE_next              */
+	TRIE,   	/* TRIE_next_fail         */
+	EVAL,   	/* EVAL_AB                */
+	EVAL,   	/* EVAL_AB_fail           */
+	CURLYX, 	/* resume_CURLYX          */
+	WHILEM, 	/* resume_WHILEM1         */
+	WHILEM, 	/* resume_WHILEM2         */
+	WHILEM, 	/* resume_WHILEM3         */
+	WHILEM, 	/* resume_WHILEM4         */
+	WHILEM, 	/* resume_WHILEM5         */
+	WHILEM, 	/* resume_WHILEM6         */
+	BRANCH, 	/* BRANCH_next            */
+	BRANCH, 	/* BRANCH_next_fail       */
+	CURLYM, 	/* CURLYM_A               */
+	CURLYM, 	/* CURLYM_A_fail          */
+	CURLYM, 	/* CURLYM_B               */
+	CURLYM, 	/* CURLYM_B_fail          */
+	IFMATCH,	/* IFMATCH_A              */
+	IFMATCH,	/* IFMATCH_A_fail         */
+	CURLY,  	/* CURLY_B_min_known      */
+	CURLY,  	/* CURLY_B_min_known_fail */
+	CURLY,  	/* CURLY_B_min            */
+	CURLY,  	/* CURLY_B_min_fail       */
+	CURLY,  	/* CURLY_B_max            */
+	CURLY,  	/* CURLY_B_max_fail       */
 };
 #endif
 
 
 #ifdef REG_COMP_C
 static const U8 regarglen[] = {
-	0,		/* END */
-	0,		/* SUCCEED */
-	0,		/* BOL */
-	0,		/* MBOL */
-	0,		/* SBOL */
-	0,		/* EOS */
-	0,		/* EOL */
-	0,		/* MEOL */
-	0,		/* SEOL */
-	0,		/* BOUND */
-	0,		/* BOUNDL */
-	0,		/* NBOUND */
-	0,		/* NBOUNDL */
-	0,		/* GPOS */
-	0,		/* REG_ANY */
-	0,		/* SANY */
-	0,		/* CANY */
-	0,		/* ANYOF */
-	0,		/* ALNUM */
-	0,		/* ALNUML */
-	0,		/* NALNUM */
-	0,		/* NALNUML */
-	0,		/* SPACE */
-	0,		/* SPACEL */
-	0,		/* NSPACE */
-	0,		/* NSPACEL */
-	0,		/* DIGIT */
-	0,		/* DIGITL */
-	0,		/* NDIGIT */
-	0,		/* NDIGITL */
-	0,		/* CLUMP */
-	0,		/* BRANCH */
-	0,		/* BACK */
-	0,		/* EXACT */
-	0,		/* EXACTF */
-	0,		/* EXACTFL */
-	0,		/* NOTHING */
-	0,		/* TAIL */
-	0,		/* STAR */
-	0,		/* PLUS */
-	EXTRA_SIZE(struct regnode_2),		/* CURLY */
-	EXTRA_SIZE(struct regnode_2),		/* CURLYN */
-	EXTRA_SIZE(struct regnode_2),		/* CURLYM */
-	EXTRA_SIZE(struct regnode_2),		/* CURLYX */
-	0,		/* WHILEM */
-	EXTRA_SIZE(struct regnode_1),		/* OPEN */
-	EXTRA_SIZE(struct regnode_1),		/* CLOSE */
-	EXTRA_SIZE(struct regnode_1),		/* REF */
-	EXTRA_SIZE(struct regnode_1),		/* REFF */
-	EXTRA_SIZE(struct regnode_1),		/* REFFL */
-	EXTRA_SIZE(struct regnode_1),		/* IFMATCH */
-	EXTRA_SIZE(struct regnode_1),		/* UNLESSM */
-	EXTRA_SIZE(struct regnode_1),		/* SUSPEND */
-	EXTRA_SIZE(struct regnode_1),		/* IFTHEN */
-	EXTRA_SIZE(struct regnode_1),		/* GROUPP */
-	EXTRA_SIZE(struct regnode_1),		/* LONGJMP */
-	EXTRA_SIZE(struct regnode_1),		/* BRANCHJ */
-	EXTRA_SIZE(struct regnode_1),		/* EVAL */
-	0,		/* MINMOD */
-	0,		/* LOGICAL */
-	EXTRA_SIZE(struct regnode_1),		/* RENUM */
-	EXTRA_SIZE(struct regnode_1),		/* TRIE */
-	EXTRA_SIZE(struct regnode_charclass),		/* TRIEC */
-	EXTRA_SIZE(struct regnode_1),		/* AHOCORASICK */
-	EXTRA_SIZE(struct regnode_charclass),		/* AHOCORASICKC */
-	0,		/* OPTIMIZED */
-	0,		/* PSEUDO */
+	0,                                   	/* END          */
+	0,                                   	/* SUCCEED      */
+	0,                                   	/* BOL          */
+	0,                                   	/* MBOL         */
+	0,                                   	/* SBOL         */
+	0,                                   	/* EOS          */
+	0,                                   	/* EOL          */
+	0,                                   	/* MEOL         */
+	0,                                   	/* SEOL         */
+	0,                                   	/* BOUND        */
+	0,                                   	/* BOUNDL       */
+	0,                                   	/* NBOUND       */
+	0,                                   	/* NBOUNDL      */
+	0,                                   	/* GPOS         */
+	0,                                   	/* REG_ANY      */
+	0,                                   	/* SANY         */
+	0,                                   	/* CANY         */
+	0,                                   	/* ANYOF        */
+	0,                                   	/* ALNUM        */
+	0,                                   	/* ALNUML       */
+	0,                                   	/* NALNUM       */
+	0,                                   	/* NALNUML      */
+	0,                                   	/* SPACE        */
+	0,                                   	/* SPACEL       */
+	0,                                   	/* NSPACE       */
+	0,                                   	/* NSPACEL      */
+	0,                                   	/* DIGIT        */
+	0,                                   	/* DIGITL       */
+	0,                                   	/* NDIGIT       */
+	0,                                   	/* NDIGITL      */
+	0,                                   	/* CLUMP        */
+	0,                                   	/* BRANCH       */
+	0,                                   	/* BACK         */
+	0,                                   	/* EXACT        */
+	0,                                   	/* EXACTF       */
+	0,                                   	/* EXACTFL      */
+	0,                                   	/* NOTHING      */
+	0,                                   	/* TAIL         */
+	0,                                   	/* STAR         */
+	0,                                   	/* PLUS         */
+	EXTRA_SIZE(struct regnode_2),        	/* CURLY        */
+	EXTRA_SIZE(struct regnode_2),        	/* CURLYN       */
+	EXTRA_SIZE(struct regnode_2),        	/* CURLYM       */
+	EXTRA_SIZE(struct regnode_2),        	/* CURLYX       */
+	0,                                   	/* WHILEM       */
+	EXTRA_SIZE(struct regnode_1),        	/* OPEN         */
+	EXTRA_SIZE(struct regnode_1),        	/* CLOSE        */
+	EXTRA_SIZE(struct regnode_1),        	/* REF          */
+	EXTRA_SIZE(struct regnode_1),        	/* REFF         */
+	EXTRA_SIZE(struct regnode_1),        	/* REFFL        */
+	EXTRA_SIZE(struct regnode_1),        	/* IFMATCH      */
+	EXTRA_SIZE(struct regnode_1),        	/* UNLESSM      */
+	EXTRA_SIZE(struct regnode_1),        	/* SUSPEND      */
+	EXTRA_SIZE(struct regnode_1),        	/* IFTHEN       */
+	EXTRA_SIZE(struct regnode_1),        	/* GROUPP       */
+	EXTRA_SIZE(struct regnode_1),        	/* LONGJMP      */
+	EXTRA_SIZE(struct regnode_1),        	/* BRANCHJ      */
+	EXTRA_SIZE(struct regnode_1),        	/* EVAL         */
+	0,                                   	/* MINMOD       */
+	0,                                   	/* LOGICAL      */
+	EXTRA_SIZE(struct regnode_1),        	/* RENUM        */
+	EXTRA_SIZE(struct regnode_1),        	/* TRIE         */
+	EXTRA_SIZE(struct regnode_charclass),	/* TRIEC        */
+	EXTRA_SIZE(struct regnode_1),        	/* AHOCORASICK  */
+	EXTRA_SIZE(struct regnode_charclass),	/* AHOCORASICKC */
+	0,                                   	/* OPTIMIZED    */
+	0,                                   	/* PSEUDO       */
 };
 
 static const char reg_off_by_arg[] = {
-	0,		/* END */
-	0,		/* SUCCEED */
-	0,		/* BOL */
-	0,		/* MBOL */
-	0,		/* SBOL */
-	0,		/* EOS */
-	0,		/* EOL */
-	0,		/* MEOL */
-	0,		/* SEOL */
-	0,		/* BOUND */
-	0,		/* BOUNDL */
-	0,		/* NBOUND */
-	0,		/* NBOUNDL */
-	0,		/* GPOS */
-	0,		/* REG_ANY */
-	0,		/* SANY */
-	0,		/* CANY */
-	0,		/* ANYOF */
-	0,		/* ALNUM */
-	0,		/* ALNUML */
-	0,		/* NALNUM */
-	0,		/* NALNUML */
-	0,		/* SPACE */
-	0,		/* SPACEL */
-	0,		/* NSPACE */
-	0,		/* NSPACEL */
-	0,		/* DIGIT */
-	0,		/* DIGITL */
-	0,		/* NDIGIT */
-	0,		/* NDIGITL */
-	0,		/* CLUMP */
-	0,		/* BRANCH */
-	0,		/* BACK */
-	0,		/* EXACT */
-	0,		/* EXACTF */
-	0,		/* EXACTFL */
-	0,		/* NOTHING */
-	0,		/* TAIL */
-	0,		/* STAR */
-	0,		/* PLUS */
-	0,		/* CURLY */
-	0,		/* CURLYN */
-	0,		/* CURLYM */
-	0,		/* CURLYX */
-	0,		/* WHILEM */
-	0,		/* OPEN */
-	0,		/* CLOSE */
-	0,		/* REF */
-	0,		/* REFF */
-	0,		/* REFFL */
-	2,		/* IFMATCH */
-	2,		/* UNLESSM */
-	1,		/* SUSPEND */
-	1,		/* IFTHEN */
-	0,		/* GROUPP */
-	1,		/* LONGJMP */
-	1,		/* BRANCHJ */
-	0,		/* EVAL */
-	0,		/* MINMOD */
-	0,		/* LOGICAL */
-	1,		/* RENUM */
-	0,		/* TRIE */
-	0,		/* TRIEC */
-	0,		/* AHOCORASICK */
-	0,		/* AHOCORASICKC */
-	0,		/* OPTIMIZED */
-	0,		/* PSEUDO */
+	0,	/* END          */
+	0,	/* SUCCEED      */
+	0,	/* BOL          */
+	0,	/* MBOL         */
+	0,	/* SBOL         */
+	0,	/* EOS          */
+	0,	/* EOL          */
+	0,	/* MEOL         */
+	0,	/* SEOL         */
+	0,	/* BOUND        */
+	0,	/* BOUNDL       */
+	0,	/* NBOUND       */
+	0,	/* NBOUNDL      */
+	0,	/* GPOS         */
+	0,	/* REG_ANY      */
+	0,	/* SANY         */
+	0,	/* CANY         */
+	0,	/* ANYOF        */
+	0,	/* ALNUM        */
+	0,	/* ALNUML       */
+	0,	/* NALNUM       */
+	0,	/* NALNUML      */
+	0,	/* SPACE        */
+	0,	/* SPACEL       */
+	0,	/* NSPACE       */
+	0,	/* NSPACEL      */
+	0,	/* DIGIT        */
+	0,	/* DIGITL       */
+	0,	/* NDIGIT       */
+	0,	/* NDIGITL      */
+	0,	/* CLUMP        */
+	0,	/* BRANCH       */
+	0,	/* BACK         */
+	0,	/* EXACT        */
+	0,	/* EXACTF       */
+	0,	/* EXACTFL      */
+	0,	/* NOTHING      */
+	0,	/* TAIL         */
+	0,	/* STAR         */
+	0,	/* PLUS         */
+	0,	/* CURLY        */
+	0,	/* CURLYN       */
+	0,	/* CURLYM       */
+	0,	/* CURLYX       */
+	0,	/* WHILEM       */
+	0,	/* OPEN         */
+	0,	/* CLOSE        */
+	0,	/* REF          */
+	0,	/* REFF         */
+	0,	/* REFFL        */
+	2,	/* IFMATCH      */
+	2,	/* UNLESSM      */
+	1,	/* SUSPEND      */
+	1,	/* IFTHEN       */
+	0,	/* GROUPP       */
+	1,	/* LONGJMP      */
+	1,	/* BRANCHJ      */
+	0,	/* EVAL         */
+	0,	/* MINMOD       */
+	0,	/* LOGICAL      */
+	1,	/* RENUM        */
+	0,	/* TRIE         */
+	0,	/* TRIEC        */
+	0,	/* AHOCORASICK  */
+	0,	/* AHOCORASICKC */
+	0,	/* OPTIMIZED    */
+	0,	/* PSEUDO       */
 };
 
 #ifdef DEBUGGING
-static const char * const reg_name[] = {
-	"END",		/*    0 */
-	"SUCCEED",		/*  0x1 */
-	"BOL",		/*  0x2 */
-	"MBOL",		/*  0x3 */
-	"SBOL",		/*  0x4 */
-	"EOS",		/*  0x5 */
-	"EOL",		/*  0x6 */
-	"MEOL",		/*  0x7 */
-	"SEOL",		/*  0x8 */
-	"BOUND",		/*  0x9 */
-	"BOUNDL",		/*  0xa */
-	"NBOUND",		/*  0xb */
-	"NBOUNDL",		/*  0xc */
-	"GPOS",		/*  0xd */
-	"REG_ANY",		/*  0xe */
-	"SANY",		/*  0xf */
-	"CANY",		/* 0x10 */
-	"ANYOF",		/* 0x11 */
-	"ALNUM",		/* 0x12 */
-	"ALNUML",		/* 0x13 */
-	"NALNUM",		/* 0x14 */
-	"NALNUML",		/* 0x15 */
-	"SPACE",		/* 0x16 */
-	"SPACEL",		/* 0x17 */
-	"NSPACE",		/* 0x18 */
-	"NSPACEL",		/* 0x19 */
-	"DIGIT",		/* 0x1a */
-	"DIGITL",		/* 0x1b */
-	"NDIGIT",		/* 0x1c */
-	"NDIGITL",		/* 0x1d */
-	"CLUMP",		/* 0x1e */
-	"BRANCH",		/* 0x1f */
-	"BACK",		/* 0x20 */
-	"EXACT",		/* 0x21 */
-	"EXACTF",		/* 0x22 */
-	"EXACTFL",		/* 0x23 */
-	"NOTHING",		/* 0x24 */
-	"TAIL",		/* 0x25 */
-	"STAR",		/* 0x26 */
-	"PLUS",		/* 0x27 */
-	"CURLY",		/* 0x28 */
-	"CURLYN",		/* 0x29 */
-	"CURLYM",		/* 0x2a */
-	"CURLYX",		/* 0x2b */
-	"WHILEM",		/* 0x2c */
-	"OPEN",		/* 0x2d */
-	"CLOSE",		/* 0x2e */
-	"REF",		/* 0x2f */
-	"REFF",		/* 0x30 */
-	"REFFL",		/* 0x31 */
-	"IFMATCH",		/* 0x32 */
-	"UNLESSM",		/* 0x33 */
-	"SUSPEND",		/* 0x34 */
-	"IFTHEN",		/* 0x35 */
-	"GROUPP",		/* 0x36 */
-	"LONGJMP",		/* 0x37 */
-	"BRANCHJ",		/* 0x38 */
-	"EVAL",		/* 0x39 */
-	"MINMOD",		/* 0x3a */
-	"LOGICAL",		/* 0x3b */
-	"RENUM",		/* 0x3c */
-	"TRIE",		/* 0x3d */
-	"TRIEC",		/* 0x3e */
-	"AHOCORASICK",		/* 0x3f */
-	"AHOCORASICKC",		/* 0x40 */
-	"OPTIMIZED",		/* 0x41 */
-	"PSEUDO",		/* 0x42 */
+extern const char * const reg_name[] = {
+	"END",                   	/* 0000 */
+	"SUCCEED",               	/* 0x01 */
+	"BOL",                   	/* 0x02 */
+	"MBOL",                  	/* 0x03 */
+	"SBOL",                  	/* 0x04 */
+	"EOS",                   	/* 0x05 */
+	"EOL",                   	/* 0x06 */
+	"MEOL",                  	/* 0x07 */
+	"SEOL",                  	/* 0x08 */
+	"BOUND",                 	/* 0x09 */
+	"BOUNDL",                	/* 0x0a */
+	"NBOUND",                	/* 0x0b */
+	"NBOUNDL",               	/* 0x0c */
+	"GPOS",                  	/* 0x0d */
+	"REG_ANY",               	/* 0x0e */
+	"SANY",                  	/* 0x0f */
+	"CANY",                  	/* 0x10 */
+	"ANYOF",                 	/* 0x11 */
+	"ALNUM",                 	/* 0x12 */
+	"ALNUML",                	/* 0x13 */
+	"NALNUM",                	/* 0x14 */
+	"NALNUML",               	/* 0x15 */
+	"SPACE",                 	/* 0x16 */
+	"SPACEL",                	/* 0x17 */
+	"NSPACE",                	/* 0x18 */
+	"NSPACEL",               	/* 0x19 */
+	"DIGIT",                 	/* 0x1a */
+	"DIGITL",                	/* 0x1b */
+	"NDIGIT",                	/* 0x1c */
+	"NDIGITL",               	/* 0x1d */
+	"CLUMP",                 	/* 0x1e */
+	"BRANCH",                	/* 0x1f */
+	"BACK",                  	/* 0x20 */
+	"EXACT",                 	/* 0x21 */
+	"EXACTF",                	/* 0x22 */
+	"EXACTFL",               	/* 0x23 */
+	"NOTHING",               	/* 0x24 */
+	"TAIL",                  	/* 0x25 */
+	"STAR",                  	/* 0x26 */
+	"PLUS",                  	/* 0x27 */
+	"CURLY",                 	/* 0x28 */
+	"CURLYN",                	/* 0x29 */
+	"CURLYM",                	/* 0x2a */
+	"CURLYX",                	/* 0x2b */
+	"WHILEM",                	/* 0x2c */
+	"OPEN",                  	/* 0x2d */
+	"CLOSE",                 	/* 0x2e */
+	"REF",                   	/* 0x2f */
+	"REFF",                  	/* 0x30 */
+	"REFFL",                 	/* 0x31 */
+	"IFMATCH",               	/* 0x32 */
+	"UNLESSM",               	/* 0x33 */
+	"SUSPEND",               	/* 0x34 */
+	"IFTHEN",                	/* 0x35 */
+	"GROUPP",                	/* 0x36 */
+	"LONGJMP",               	/* 0x37 */
+	"BRANCHJ",               	/* 0x38 */
+	"EVAL",                  	/* 0x39 */
+	"MINMOD",                	/* 0x3a */
+	"LOGICAL",               	/* 0x3b */
+	"RENUM",                 	/* 0x3c */
+	"TRIE",                  	/* 0x3d */
+	"TRIEC",                 	/* 0x3e */
+	"AHOCORASICK",           	/* 0x3f */
+	"AHOCORASICKC",          	/* 0x40 */
+	"OPTIMIZED",             	/* 0x41 */
+	"PSEUDO",                	/* 0x42 */
+	/* ------------ States ------------- */
+	"TRIE_next",             	/* 0x43 */
+	"TRIE_next_fail",        	/* 0x44 */
+	"EVAL_AB",               	/* 0x45 */
+	"EVAL_AB_fail",          	/* 0x46 */
+	"resume_CURLYX",         	/* 0x47 */
+	"resume_WHILEM1",        	/* 0x48 */
+	"resume_WHILEM2",        	/* 0x49 */
+	"resume_WHILEM3",        	/* 0x4a */
+	"resume_WHILEM4",        	/* 0x4b */
+	"resume_WHILEM5",        	/* 0x4c */
+	"resume_WHILEM6",        	/* 0x4d */
+	"BRANCH_next",           	/* 0x4e */
+	"BRANCH_next_fail",      	/* 0x4f */
+	"CURLYM_A",              	/* 0x50 */
+	"CURLYM_A_fail",         	/* 0x51 */
+	"CURLYM_B",              	/* 0x52 */
+	"CURLYM_B_fail",         	/* 0x53 */
+	"IFMATCH_A",             	/* 0x54 */
+	"IFMATCH_A_fail",        	/* 0x55 */
+	"CURLY_B_min_known",     	/* 0x56 */
+	"CURLY_B_min_known_fail",	/* 0x57 */
+	"CURLY_B_min",           	/* 0x58 */
+	"CURLY_B_min_fail",      	/* 0x59 */
+	"CURLY_B_max",           	/* 0x5a */
+	"CURLY_B_max_fail",      	/* 0x5b */
 };
-
-static const int reg_num = 67;
-
 #endif /* DEBUGGING */
+#else
+#ifdef DEBUGGING
+extern const char * const reg_name[];
+#endif
 #endif /* REG_COMP_C */
 
 /* ex: set ro: */