X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/693fefec6759ebf0a9ec40a0f59346d86831349c..36f453d19563f9476d4310b8310ce4080209b04f:/regnodes.h diff --git a/regnodes.h b/regnodes.h index 84096d6..98de0bb 100644 --- a/regnodes.h +++ b/regnodes.h @@ -4,167 +4,1084 @@ Any changes made here will be lost! */ +#if defined(PERL_CORE) || defined(PERL_EXT_RE_BUILD) + /* Regops and State definitions */ -#define REGNODE_MAX 114 -#define REGMATCH_STATE_MAX 154 - -#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 using native charset semantics for non-utf8 */ -#define BOUNDL 10 /* 0x0a Match "" at any locale word boundary */ -#define BOUNDU 11 /* 0x0b Match "" at any word boundary using Unicode semantics */ -#define BOUNDA 12 /* 0x0c Match "" at any word boundary using ASCII semantics */ -#define NBOUND 13 /* 0x0d Match "" at any word non-boundary using native charset semantics for non-utf8 */ -#define NBOUNDL 14 /* 0x0e Match "" at any locale word non-boundary */ -#define NBOUNDU 15 /* 0x0f Match "" at any word non-boundary using Unicode semantics */ -#define NBOUNDA 16 /* 0x10 Match "" at any word non-boundary using ASCII semantics */ -#define GPOS 17 /* 0x11 Matches where last m//g left off. */ -#define REG_ANY 18 /* 0x12 Match any one character (except newline). */ -#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 ANYOFV 22 /* 0x16 Match character in (or not in) this class, can match-multiple chars */ -#define ALNUM 23 /* 0x17 Match any alphanumeric character using native charset semantics for non-utf8 */ -#define ALNUML 24 /* 0x18 Match any alphanumeric char in locale */ -#define ALNUMU 25 /* 0x19 Match any alphanumeric char using Unicode semantics */ -#define ALNUMA 26 /* 0x1a Match [A-Za-z_0-9] */ -#define NALNUM 27 /* 0x1b Match any non-alphanumeric character using native charset semantics for non-utf8 */ -#define NALNUML 28 /* 0x1c Match any non-alphanumeric char in locale */ -#define NALNUMU 29 /* 0x1d Match any non-alphanumeric char using Unicode semantics */ -#define NALNUMA 30 /* 0x1e Match [^A-Za-z_0-9] */ -#define SPACE 31 /* 0x1f Match any whitespace character using native charset semantics for non-utf8 */ -#define SPACEL 32 /* 0x20 Match any whitespace char in locale */ -#define SPACEU 33 /* 0x21 Match any whitespace char using Unicode semantics */ -#define SPACEA 34 /* 0x22 Match [ \t\n\f\r] */ -#define NSPACE 35 /* 0x23 Match any non-whitespace character using native charset semantics for non-utf8 */ -#define NSPACEL 36 /* 0x24 Match any non-whitespace char in locale */ -#define NSPACEU 37 /* 0x25 Match any non-whitespace char using Unicode semantics */ -#define NSPACEA 38 /* 0x26 Match [^ \t\n\f\r] */ -#define DIGIT 39 /* 0x27 Match any numeric character using native charset semantics for non-utf8 */ -#define DIGITL 40 /* 0x28 Match any numeric character in locale */ -#define PLACEHOLDER1 41 /* 0x29 placeholder for missing DIGITU */ -#define DIGITA 42 /* 0x2a Match [0-9] */ -#define NDIGIT 43 /* 0x2b Match any non-numeric character using native charset semantics for non-utf8 */ -#define NDIGITL 44 /* 0x2c Match any non-numeric character in locale */ -#define PLACEHOLDER2 45 /* 0x2d placeholder for missing NDIGITU */ -#define NDIGITA 46 /* 0x2e Match [^0-9] */ -#define CLUMP 47 /* 0x2f Match any extended grapheme cluster sequence */ -#define BRANCH 48 /* 0x30 Match this alternative, or the next... */ -#define BACK 49 /* 0x31 Match "", "next" ptr points backward. */ -#define EXACT 50 /* 0x32 Match this string (preceded by length). */ -#define EXACTF 51 /* 0x33 Match this non-UTF-8 string (not guaranteed to be folded) using /id rules (w/len). */ -#define EXACTFL 52 /* 0x34 Match this string (not guaranteed to be folded) using /il rules (w/len). */ -#define EXACTFU 53 /* 0x35 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 54 /* 0x36 Match this string (not guaranteed to be folded) using /iaa rules (w/len). */ -#define EXACTFU_SS 55 /* 0x37 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 56 /* 0x38 Match this folded UTF-8 string using /iu rules */ -#define NOTHING 57 /* 0x39 Match empty string. */ -#define TAIL 58 /* 0x3a Match empty string. Can jump here from outside. */ -#define STAR 59 /* 0x3b Match this (simple) thing 0 or more times. */ -#define PLUS 60 /* 0x3c Match this (simple) thing 1 or more times. */ -#define CURLY 61 /* 0x3d Match this simple thing {n,m} times. */ -#define CURLYN 62 /* 0x3e Capture next-after-this simple thing */ -#define CURLYM 63 /* 0x3f Capture this medium-complex thing {n,m} times. */ -#define CURLYX 64 /* 0x40 Match this complex thing {n,m} times. */ -#define WHILEM 65 /* 0x41 Do curly processing and see if rest matches. */ -#define OPEN 66 /* 0x42 Mark this point in input as start of */ -#define CLOSE 67 /* 0x43 Analogous to OPEN. */ -#define REF 68 /* 0x44 Match some already matched string */ -#define REFF 69 /* 0x45 Match already matched string, folded using native charset semantics for non-utf8 */ -#define REFFL 70 /* 0x46 Match already matched string, folded in loc. */ -#define REFFU 71 /* 0x47 Match already matched string, folded using unicode semantics for non-utf8 */ -#define REFFA 72 /* 0x48 Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */ -#define NREF 73 /* 0x49 Match some already matched string */ -#define NREFF 74 /* 0x4a Match already matched string, folded using native charset semantics for non-utf8 */ -#define NREFFL 75 /* 0x4b Match already matched string, folded in loc. */ -#define NREFFU 76 /* 0x4c Match already matched string, folded using unicode semantics for non-utf8 */ -#define NREFFA 77 /* 0x4d Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */ -#define IFMATCH 78 /* 0x4e Succeeds if the following matches. */ -#define UNLESSM 79 /* 0x4f Fails if the following matches. */ -#define SUSPEND 80 /* 0x50 "Independent" sub-RE. */ -#define IFTHEN 81 /* 0x51 Switch, should be preceded by switcher . */ -#define GROUPP 82 /* 0x52 Whether the group matched. */ -#define LONGJMP 83 /* 0x53 Jump far away. */ -#define BRANCHJ 84 /* 0x54 BRANCH with long offset. */ -#define EVAL 85 /* 0x55 Execute some Perl code. */ -#define MINMOD 86 /* 0x56 Next operator is not greedy. */ -#define LOGICAL 87 /* 0x57 Next opcode should set the flag only. */ -#define RENUM 88 /* 0x58 Group with independently numbered parens. */ -#define TRIE 89 /* 0x59 Match many EXACT(F[ALU]?)? at once. flags==type */ -#define TRIEC 90 /* 0x5a Same as TRIE, but with embedded charclass data */ -#define AHOCORASICK 91 /* 0x5b Aho Corasick stclass. flags==type */ -#define AHOCORASICKC 92 /* 0x5c Same as AHOCORASICK, but with embedded charclass data */ -#define GOSUB 93 /* 0x5d recurse to paren arg1 at (signed) ofs arg2 */ -#define GOSTART 94 /* 0x5e recurse to start of pattern */ -#define NGROUPP 95 /* 0x5f Whether the group matched. */ -#define INSUBP 96 /* 0x60 Whether we are in a specific recurse. */ -#define DEFINEP 97 /* 0x61 Never execute directly. */ -#define ENDLIKE 98 /* 0x62 Used only for the type field of verbs */ -#define OPFAIL 99 /* 0x63 Same as (?!) */ -#define ACCEPT 100 /* 0x64 Accepts the current matched string. */ -#define VERB 101 /* 0x65 Used only for the type field of verbs */ -#define PRUNE 102 /* 0x66 Pattern fails at this startpoint if no-backtracking through this */ -#define MARKPOINT 103 /* 0x67 Push the current location for rollback by cut. */ -#define SKIP 104 /* 0x68 On failure skip forward (to the mark) before retrying */ -#define COMMIT 105 /* 0x69 Pattern fails outright if backtracking through this */ -#define CUTGROUP 106 /* 0x6a On failure go to the next alternation in the group */ -#define KEEPS 107 /* 0x6b $& begins here. */ -#define LNBREAK 108 /* 0x6c generic newline pattern */ -#define VERTWS 109 /* 0x6d vertical whitespace (Perl 6) */ -#define NVERTWS 110 /* 0x6e not vertical whitespace (Perl 6) */ -#define HORIZWS 111 /* 0x6f horizontal whitespace (Perl 6) */ -#define NHORIZWS 112 /* 0x70 not horizontal whitespace (Perl 6) */ -#define OPTIMIZED 113 /* 0x71 Placeholder for dump. */ -#define PSEUDO 114 /* 0x72 Pseudo opcode for internal use. */ +#define REGNODE_MAX 109 +#define REGMATCH_STATE_MAX 149 + +/* -- For regexec.c to switch on target being utf8 (t8) or not (tb, b='byte'); + * same with pattern (p8, pb) -- */ +#define with_tp_UTF8ness(op, t_utf8, p_utf8) \ + (((op) << 2) + (cBOOL(t_utf8) << 1) + cBOOL(p_utf8)) + +/* The #defines below give both the basic regnode and the expanded version for + switching on utf8ness */ +#define END 0 /* 0x00 End of program. */ +#define END_tb_pb 0 /* 0x000 */ +#define END_tb_p8 1 /* 0x001 */ +#define END_t8_pb 2 /* 0x002 */ +#define END_t8_p8 3 /* 0x003 */ + +#define SUCCEED 1 /* 0x01 Return from a subroutine, + basically. */ +#define SUCCEED_tb_pb 4 /* 0x004 */ +#define SUCCEED_tb_p8 5 /* 0x005 */ +#define SUCCEED_t8_pb 6 /* 0x006 */ +#define SUCCEED_t8_p8 7 /* 0x007 */ + +#define SBOL 2 /* 0x02 Match "" at beginning of + line: /^/, /\A/ */ +#define SBOL_tb_pb 8 /* 0x008 */ +#define SBOL_tb_p8 9 /* 0x009 */ +#define SBOL_t8_pb 10 /* 0x00a */ +#define SBOL_t8_p8 11 /* 0x00b */ + +#define BOL 2 /* 0x02 Match "" at beginning of + line: /^/, /\A/ */ +#define BOL_tb_pb 8 /* 0x008 */ +#define BOL_tb_p8 9 /* 0x009 */ +#define BOL_t8_pb 10 /* 0x00a */ +#define BOL_t8_p8 11 /* 0x00b */ + +#define MBOL 3 /* 0x03 Same, assuming multiline: + /^/m */ +#define MBOL_tb_pb 12 /* 0x00c */ +#define MBOL_tb_p8 13 /* 0x00d */ +#define MBOL_t8_pb 14 /* 0x00e */ +#define MBOL_t8_p8 15 /* 0x00f */ + +#define SEOL 4 /* 0x04 Match "" at end of line: + /$/ */ +#define SEOL_tb_pb 16 /* 0x010 */ +#define SEOL_tb_p8 17 /* 0x011 */ +#define SEOL_t8_pb 18 /* 0x012 */ +#define SEOL_t8_p8 19 /* 0x013 */ + +#define EOL 4 /* 0x04 Match "" at end of line: + /$/ */ +#define EOL_tb_pb 16 /* 0x010 */ +#define EOL_tb_p8 17 /* 0x011 */ +#define EOL_t8_pb 18 /* 0x012 */ +#define EOL_t8_p8 19 /* 0x013 */ + +#define MEOL 5 /* 0x05 Same, assuming multiline: + /$/m */ +#define MEOL_tb_pb 20 /* 0x014 */ +#define MEOL_tb_p8 21 /* 0x015 */ +#define MEOL_t8_pb 22 /* 0x016 */ +#define MEOL_t8_p8 23 /* 0x017 */ + +#define EOS 6 /* 0x06 Match "" at end of string: + /\z/ */ +#define EOS_tb_pb 24 /* 0x018 */ +#define EOS_tb_p8 25 /* 0x019 */ +#define EOS_t8_pb 26 /* 0x01a */ +#define EOS_t8_p8 27 /* 0x01b */ + +#define GPOS 7 /* 0x07 Matches where last m//g + left off. */ +#define GPOS_tb_pb 28 /* 0x01c */ +#define GPOS_tb_p8 29 /* 0x01d */ +#define GPOS_t8_pb 30 /* 0x01e */ +#define GPOS_t8_p8 31 /* 0x01f */ + +#define BOUND 8 /* 0x08 Like BOUNDA for non-utf8, + otherwise like BOUNDU */ +#define BOUND_tb_pb 32 /* 0x020 */ +#define BOUND_tb_p8 33 /* 0x021 */ +#define BOUND_t8_pb 34 /* 0x022 */ +#define BOUND_t8_p8 35 /* 0x023 */ + +#define BOUNDL 9 /* 0x09 Like BOUND/BOUNDU, but \w + and \W are defined by current + locale */ +#define BOUNDL_tb_pb 36 /* 0x024 */ +#define BOUNDL_tb_p8 37 /* 0x025 */ +#define BOUNDL_t8_pb 38 /* 0x026 */ +#define BOUNDL_t8_p8 39 /* 0x027 */ + +#define BOUNDU 10 /* 0x0a Match "" at any boundary of + a given type using /u rules. */ +#define BOUNDU_tb_pb 40 /* 0x028 */ +#define BOUNDU_tb_p8 41 /* 0x029 */ +#define BOUNDU_t8_pb 42 /* 0x02a */ +#define BOUNDU_t8_p8 43 /* 0x02b */ + +#define BOUNDA 11 /* 0x0b Match "" at any boundary + between \w\W or \W\w, where \w + is [_a-zA-Z0-9] */ +#define BOUNDA_tb_pb 44 /* 0x02c */ +#define BOUNDA_tb_p8 45 /* 0x02d */ +#define BOUNDA_t8_pb 46 /* 0x02e */ +#define BOUNDA_t8_p8 47 /* 0x02f */ + +#define NBOUND 12 /* 0x0c Like NBOUNDA for non-utf8, + otherwise like BOUNDU */ +#define NBOUND_tb_pb 48 /* 0x030 */ +#define NBOUND_tb_p8 49 /* 0x031 */ +#define NBOUND_t8_pb 50 /* 0x032 */ +#define NBOUND_t8_p8 51 /* 0x033 */ + +#define NBOUNDL 13 /* 0x0d Like NBOUND/NBOUNDU, but \w + and \W are defined by current + locale */ +#define NBOUNDL_tb_pb 52 /* 0x034 */ +#define NBOUNDL_tb_p8 53 /* 0x035 */ +#define NBOUNDL_t8_pb 54 /* 0x036 */ +#define NBOUNDL_t8_p8 55 /* 0x037 */ + +#define NBOUNDU 14 /* 0x0e Match "" at any + non-boundary of a given type + using using /u rules. */ +#define NBOUNDU_tb_pb 56 /* 0x038 */ +#define NBOUNDU_tb_p8 57 /* 0x039 */ +#define NBOUNDU_t8_pb 58 /* 0x03a */ +#define NBOUNDU_t8_p8 59 /* 0x03b */ + +#define NBOUNDA 15 /* 0x0f Match "" betweeen any \w\w + or \W\W, where \w is + [_a-zA-Z0-9] */ +#define NBOUNDA_tb_pb 60 /* 0x03c */ +#define NBOUNDA_tb_p8 61 /* 0x03d */ +#define NBOUNDA_t8_pb 62 /* 0x03e */ +#define NBOUNDA_t8_p8 63 /* 0x03f */ + +#define REG_ANY 16 /* 0x10 Match any one character + (except newline). */ +#define REG_ANY_tb_pb 64 /* 0x040 */ +#define REG_ANY_tb_p8 65 /* 0x041 */ +#define REG_ANY_t8_pb 66 /* 0x042 */ +#define REG_ANY_t8_p8 67 /* 0x043 */ + +#define SANY 17 /* 0x11 Match any one character. */ +#define SANY_tb_pb 68 /* 0x044 */ +#define SANY_tb_p8 69 /* 0x045 */ +#define SANY_t8_pb 70 /* 0x046 */ +#define SANY_t8_p8 71 /* 0x047 */ + +#define ANYOF 18 /* 0x12 Match character in (or not + in) this class, single char + match only */ +#define ANYOF_tb_pb 72 /* 0x048 */ +#define ANYOF_tb_p8 73 /* 0x049 */ +#define ANYOF_t8_pb 74 /* 0x04a */ +#define ANYOF_t8_p8 75 /* 0x04b */ + +#define ANYOFD 19 /* 0x13 Like ANYOF, but /d is in + effect */ +#define ANYOFD_tb_pb 76 /* 0x04c */ +#define ANYOFD_tb_p8 77 /* 0x04d */ +#define ANYOFD_t8_pb 78 /* 0x04e */ +#define ANYOFD_t8_p8 79 /* 0x04f */ + +#define ANYOFL 20 /* 0x14 Like ANYOF, but /l is in + effect */ +#define ANYOFL_tb_pb 80 /* 0x050 */ +#define ANYOFL_tb_p8 81 /* 0x051 */ +#define ANYOFL_t8_pb 82 /* 0x052 */ +#define ANYOFL_t8_p8 83 /* 0x053 */ + +#define ANYOFPOSIXL 21 /* 0x15 Like ANYOFL, but matches + [[:posix:]] classes */ +#define ANYOFPOSIXL_tb_pb 84 /* 0x054 */ +#define ANYOFPOSIXL_tb_p8 85 /* 0x055 */ +#define ANYOFPOSIXL_t8_pb 86 /* 0x056 */ +#define ANYOFPOSIXL_t8_p8 87 /* 0x057 */ + +#define ANYOFH 22 /* 0x16 Like ANYOF, but only has + "High" matches, none in the + bitmap; the flags field contains + the lowest matchable UTF-8 start + byte */ +#define ANYOFH_tb_pb 88 /* 0x058 */ +#define ANYOFH_tb_p8 89 /* 0x059 */ +#define ANYOFH_t8_pb 90 /* 0x05a */ +#define ANYOFH_t8_p8 91 /* 0x05b */ + +#define ANYOFHb 23 /* 0x17 Like ANYOFH, but all + matches share the same UTF-8 + start byte, given in the flags + field */ +#define ANYOFHb_tb_pb 92 /* 0x05c */ +#define ANYOFHb_tb_p8 93 /* 0x05d */ +#define ANYOFHb_t8_pb 94 /* 0x05e */ +#define ANYOFHb_t8_p8 95 /* 0x05f */ + +#define ANYOFHr 24 /* 0x18 Like ANYOFH, but the flags + field contains packed bounds for + all matchable UTF-8 start bytes. + */ +#define ANYOFHr_tb_pb 96 /* 0x060 */ +#define ANYOFHr_tb_p8 97 /* 0x061 */ +#define ANYOFHr_t8_pb 98 /* 0x062 */ +#define ANYOFHr_t8_p8 99 /* 0x063 */ + +#define ANYOFHs 25 /* 0x19 Like ANYOFHb, but has a + string field that gives the + leading matchable UTF-8 bytes; + flags field is len */ +#define ANYOFHs_tb_pb 100 /* 0x064 */ +#define ANYOFHs_tb_p8 101 /* 0x065 */ +#define ANYOFHs_t8_pb 102 /* 0x066 */ +#define ANYOFHs_t8_p8 103 /* 0x067 */ + +#define ANYOFR 26 /* 0x1a Matches any character in + the range given by its packed + args: upper 12 bits is the max + delta from the base lower 20; + the flags field contains the + lowest matchable UTF-8 start + byte */ +#define ANYOFR_tb_pb 104 /* 0x068 */ +#define ANYOFR_tb_p8 105 /* 0x069 */ +#define ANYOFR_t8_pb 106 /* 0x06a */ +#define ANYOFR_t8_p8 107 /* 0x06b */ + +#define ANYOFRb 27 /* 0x1b Like ANYOFR, but all + matches share the same UTF-8 + start byte, given in the flags + field */ +#define ANYOFRb_tb_pb 108 /* 0x06c */ +#define ANYOFRb_tb_p8 109 /* 0x06d */ +#define ANYOFRb_t8_pb 110 /* 0x06e */ +#define ANYOFRb_t8_p8 111 /* 0x06f */ + +#define ANYOFM 28 /* 0x1c Like ANYOF, but matches an + invariant byte as determined by + the mask and arg */ +#define ANYOFM_tb_pb 112 /* 0x070 */ +#define ANYOFM_tb_p8 113 /* 0x071 */ +#define ANYOFM_t8_pb 114 /* 0x072 */ +#define ANYOFM_t8_p8 115 /* 0x073 */ + +#define NANYOFM 29 /* 0x1d complement of ANYOFM */ +#define NANYOFM_tb_pb 116 /* 0x074 */ +#define NANYOFM_tb_p8 117 /* 0x075 */ +#define NANYOFM_t8_pb 118 /* 0x076 */ +#define NANYOFM_t8_p8 119 /* 0x077 */ + +#define POSIXD 30 /* 0x1e Some [[:class:]] under /d; + the FLAGS field gives which one + */ +#define POSIXD_tb_pb 120 /* 0x078 */ +#define POSIXD_tb_p8 121 /* 0x079 */ +#define POSIXD_t8_pb 122 /* 0x07a */ +#define POSIXD_t8_p8 123 /* 0x07b */ + +#define POSIXL 31 /* 0x1f Some [[:class:]] under /l; + the FLAGS field gives which one + */ +#define POSIXL_tb_pb 124 /* 0x07c */ +#define POSIXL_tb_p8 125 /* 0x07d */ +#define POSIXL_t8_pb 126 /* 0x07e */ +#define POSIXL_t8_p8 127 /* 0x07f */ + +#define POSIXU 32 /* 0x20 Some [[:class:]] under /u; + the FLAGS field gives which one + */ +#define POSIXU_tb_pb 128 /* 0x080 */ +#define POSIXU_tb_p8 129 /* 0x081 */ +#define POSIXU_t8_pb 130 /* 0x082 */ +#define POSIXU_t8_p8 131 /* 0x083 */ + +#define POSIXA 33 /* 0x21 Some [[:class:]] under /a; + the FLAGS field gives which one + */ +#define POSIXA_tb_pb 132 /* 0x084 */ +#define POSIXA_tb_p8 133 /* 0x085 */ +#define POSIXA_t8_pb 134 /* 0x086 */ +#define POSIXA_t8_p8 135 /* 0x087 */ + +#define NPOSIXD 34 /* 0x22 complement of POSIXD, + [[:^class:]] */ +#define NPOSIXD_tb_pb 136 /* 0x088 */ +#define NPOSIXD_tb_p8 137 /* 0x089 */ +#define NPOSIXD_t8_pb 138 /* 0x08a */ +#define NPOSIXD_t8_p8 139 /* 0x08b */ + +#define NPOSIXL 35 /* 0x23 complement of POSIXL, + [[:^class:]] */ +#define NPOSIXL_tb_pb 140 /* 0x08c */ +#define NPOSIXL_tb_p8 141 /* 0x08d */ +#define NPOSIXL_t8_pb 142 /* 0x08e */ +#define NPOSIXL_t8_p8 143 /* 0x08f */ + +#define NPOSIXU 36 /* 0x24 complement of POSIXU, + [[:^class:]] */ +#define NPOSIXU_tb_pb 144 /* 0x090 */ +#define NPOSIXU_tb_p8 145 /* 0x091 */ +#define NPOSIXU_t8_pb 146 /* 0x092 */ +#define NPOSIXU_t8_p8 147 /* 0x093 */ + +#define NPOSIXA 37 /* 0x25 complement of POSIXA, + [[:^class:]] */ +#define NPOSIXA_tb_pb 148 /* 0x094 */ +#define NPOSIXA_tb_p8 149 /* 0x095 */ +#define NPOSIXA_t8_pb 150 /* 0x096 */ +#define NPOSIXA_t8_p8 151 /* 0x097 */ + +#define CLUMP 38 /* 0x26 Match any extended grapheme + cluster sequence */ +#define CLUMP_tb_pb 152 /* 0x098 */ +#define CLUMP_tb_p8 153 /* 0x099 */ +#define CLUMP_t8_pb 154 /* 0x09a */ +#define CLUMP_t8_p8 155 /* 0x09b */ + +#define BRANCH 39 /* 0x27 Match this alternative, or + the next... */ +#define BRANCH_tb_pb 156 /* 0x09c */ +#define BRANCH_tb_p8 157 /* 0x09d */ +#define BRANCH_t8_pb 158 /* 0x09e */ +#define BRANCH_t8_p8 159 /* 0x09f */ + +#define EXACT 40 /* 0x28 Match this string (flags + field is the length). */ +#define EXACT_tb_pb 160 /* 0x0a0 */ +#define EXACT_tb_p8 161 /* 0x0a1 */ +#define EXACT_t8_pb 162 /* 0x0a2 */ +#define EXACT_t8_p8 163 /* 0x0a3 */ + +#define LEXACT 41 /* 0x29 Match this long string + (preceded by length; flags + unused). */ +#define LEXACT_tb_pb 164 /* 0x0a4 */ +#define LEXACT_tb_p8 165 /* 0x0a5 */ +#define LEXACT_t8_pb 166 /* 0x0a6 */ +#define LEXACT_t8_p8 167 /* 0x0a7 */ + +#define EXACTL 42 /* 0x2a Like EXACT, but /l is in + effect (used so locale-related + warnings can be checked for) */ +#define EXACTL_tb_pb 168 /* 0x0a8 */ +#define EXACTL_tb_p8 169 /* 0x0a9 */ +#define EXACTL_t8_pb 170 /* 0x0aa */ +#define EXACTL_t8_p8 171 /* 0x0ab */ + +#define EXACTF 43 /* 0x2b Like EXACT, but match using + /id rules; (string not UTF-8, + ASCII folded; non-ASCII not) */ +#define EXACTF_tb_pb 172 /* 0x0ac */ +#define EXACTF_tb_p8 173 /* 0x0ad */ +#define EXACTF_t8_pb 174 /* 0x0ae */ +#define EXACTF_t8_p8 175 /* 0x0af */ + +#define EXACTFL 44 /* 0x2c Like EXACT, but match using + /il rules; (string not likely to + be folded) */ +#define EXACTFL_tb_pb 176 /* 0x0b0 */ +#define EXACTFL_tb_p8 177 /* 0x0b1 */ +#define EXACTFL_t8_pb 178 /* 0x0b2 */ +#define EXACTFL_t8_p8 179 /* 0x0b3 */ + +#define EXACTFU 45 /* 0x2d Like EXACT, but match using + /iu rules; (string folded) */ +#define EXACTFU_tb_pb 180 /* 0x0b4 */ +#define EXACTFU_tb_p8 181 /* 0x0b5 */ +#define EXACTFU_t8_pb 182 /* 0x0b6 */ +#define EXACTFU_t8_p8 183 /* 0x0b7 */ + +#define EXACTFAA 46 /* 0x2e Like EXACT, but match using + /iaa rules; (string folded + except MICRO in non-UTF8 + patterns; doesn't contain SHARP + S unless UTF-8; folded length <= + unfolded) */ +#define EXACTFAA_tb_pb 184 /* 0x0b8 */ +#define EXACTFAA_tb_p8 185 /* 0x0b9 */ +#define EXACTFAA_t8_pb 186 /* 0x0ba */ +#define EXACTFAA_t8_p8 187 /* 0x0bb */ + +#define EXACTFAA_NO_TRIE 47 /* 0x2f Like EXACTFAA, (string not + UTF-8, folded except: MICRO, + SHARP S; folded length <= + unfolded, not currently + trie-able) */ +#define EXACTFAA_NO_TRIE_tb_pb 188 /* 0x0bc */ +#define EXACTFAA_NO_TRIE_tb_p8 189 /* 0x0bd */ +#define EXACTFAA_NO_TRIE_t8_pb 190 /* 0x0be */ +#define EXACTFAA_NO_TRIE_t8_p8 191 /* 0x0bf */ + +#define EXACTFUP 48 /* 0x30 Like EXACT, but match using + /iu rules; (string not UTF-8, + folded except MICRO: hence + Problematic) */ +#define EXACTFUP_tb_pb 192 /* 0x0c0 */ +#define EXACTFUP_tb_p8 193 /* 0x0c1 */ +#define EXACTFUP_t8_pb 194 /* 0x0c2 */ +#define EXACTFUP_t8_p8 195 /* 0x0c3 */ + +#define EXACTFLU8 49 /* 0x31 Like EXACTFU, but use /il, + UTF-8, (string is folded, and + everything in it is above 255 */ +#define EXACTFLU8_tb_pb 196 /* 0x0c4 */ +#define EXACTFLU8_tb_p8 197 /* 0x0c5 */ +#define EXACTFLU8_t8_pb 198 /* 0x0c6 */ +#define EXACTFLU8_t8_p8 199 /* 0x0c7 */ + +#define EXACT_REQ8 50 /* 0x32 Like EXACT, but only UTF-8 + encoded targets can match */ +#define EXACT_REQ8_tb_pb 200 /* 0x0c8 */ +#define EXACT_REQ8_tb_p8 201 /* 0x0c9 */ +#define EXACT_REQ8_t8_pb 202 /* 0x0ca */ +#define EXACT_REQ8_t8_p8 203 /* 0x0cb */ + +#define LEXACT_REQ8 51 /* 0x33 Like LEXACT, but only UTF-8 + encoded targets can match */ +#define LEXACT_REQ8_tb_pb 204 /* 0x0cc */ +#define LEXACT_REQ8_tb_p8 205 /* 0x0cd */ +#define LEXACT_REQ8_t8_pb 206 /* 0x0ce */ +#define LEXACT_REQ8_t8_p8 207 /* 0x0cf */ + +#define EXACTFU_REQ8 52 /* 0x34 Like EXACTFU, but only + UTF-8 encoded targets can match + */ +#define EXACTFU_REQ8_tb_pb 208 /* 0x0d0 */ +#define EXACTFU_REQ8_tb_p8 209 /* 0x0d1 */ +#define EXACTFU_REQ8_t8_pb 210 /* 0x0d2 */ +#define EXACTFU_REQ8_t8_p8 211 /* 0x0d3 */ + +#define EXACTFU_S_EDGE 53 /* 0x35 /di rules, but nothing in + it precludes /ui, except begins + and/or ends with [Ss]; (string + not UTF-8; compile-time only) */ +#define EXACTFU_S_EDGE_tb_pb 212 /* 0x0d4 */ +#define EXACTFU_S_EDGE_tb_p8 213 /* 0x0d5 */ +#define EXACTFU_S_EDGE_t8_pb 214 /* 0x0d6 */ +#define EXACTFU_S_EDGE_t8_p8 215 /* 0x0d7 */ + +#define LNBREAK 54 /* 0x36 generic newline pattern */ +#define LNBREAK_tb_pb 216 /* 0x0d8 */ +#define LNBREAK_tb_p8 217 /* 0x0d9 */ +#define LNBREAK_t8_pb 218 /* 0x0da */ +#define LNBREAK_t8_p8 219 /* 0x0db */ + +#define TRIE 55 /* 0x37 Match many EXACT(F[ALU]?)? + at once. flags==type */ +#define TRIE_tb_pb 220 /* 0x0dc */ +#define TRIE_tb_p8 221 /* 0x0dd */ +#define TRIE_t8_pb 222 /* 0x0de */ +#define TRIE_t8_p8 223 /* 0x0df */ + +#define TRIEC 56 /* 0x38 Same as TRIE, but with + embedded charclass data */ +#define TRIEC_tb_pb 224 /* 0x0e0 */ +#define TRIEC_tb_p8 225 /* 0x0e1 */ +#define TRIEC_t8_pb 226 /* 0x0e2 */ +#define TRIEC_t8_p8 227 /* 0x0e3 */ + +#define AHOCORASICK 57 /* 0x39 Aho Corasick stclass. + flags==type */ +#define AHOCORASICK_tb_pb 228 /* 0x0e4 */ +#define AHOCORASICK_tb_p8 229 /* 0x0e5 */ +#define AHOCORASICK_t8_pb 230 /* 0x0e6 */ +#define AHOCORASICK_t8_p8 231 /* 0x0e7 */ + +#define AHOCORASICKC 58 /* 0x3a Same as AHOCORASICK, but + with embedded charclass data */ +#define AHOCORASICKC_tb_pb 232 /* 0x0e8 */ +#define AHOCORASICKC_tb_p8 233 /* 0x0e9 */ +#define AHOCORASICKC_t8_pb 234 /* 0x0ea */ +#define AHOCORASICKC_t8_p8 235 /* 0x0eb */ + +#define NOTHING 59 /* 0x3b Match empty string. */ +#define NOTHING_tb_pb 236 /* 0x0ec */ +#define NOTHING_tb_p8 237 /* 0x0ed */ +#define NOTHING_t8_pb 238 /* 0x0ee */ +#define NOTHING_t8_p8 239 /* 0x0ef */ + +#define TAIL 60 /* 0x3c Match empty string. Can + jump here from outside. */ +#define TAIL_tb_pb 240 /* 0x0f0 */ +#define TAIL_tb_p8 241 /* 0x0f1 */ +#define TAIL_t8_pb 242 /* 0x0f2 */ +#define TAIL_t8_p8 243 /* 0x0f3 */ + +#define STAR 61 /* 0x3d Match this (simple) thing 0 + or more times. */ +#define STAR_tb_pb 244 /* 0x0f4 */ +#define STAR_tb_p8 245 /* 0x0f5 */ +#define STAR_t8_pb 246 /* 0x0f6 */ +#define STAR_t8_p8 247 /* 0x0f7 */ + +#define PLUS 62 /* 0x3e Match this (simple) thing 1 + or more times. */ +#define PLUS_tb_pb 248 /* 0x0f8 */ +#define PLUS_tb_p8 249 /* 0x0f9 */ +#define PLUS_t8_pb 250 /* 0x0fa */ +#define PLUS_t8_p8 251 /* 0x0fb */ + +#define CURLY 63 /* 0x3f Match this simple thing + {n,m} times. */ +#define CURLY_tb_pb 252 /* 0x0fc */ +#define CURLY_tb_p8 253 /* 0x0fd */ +#define CURLY_t8_pb 254 /* 0x0fe */ +#define CURLY_t8_p8 255 /* 0x0ff */ + +#define CURLYN 64 /* 0x40 Capture next-after-this + simple thing */ +#define CURLYN_tb_pb 256 /* 0x100 */ +#define CURLYN_tb_p8 257 /* 0x101 */ +#define CURLYN_t8_pb 258 /* 0x102 */ +#define CURLYN_t8_p8 259 /* 0x103 */ + +#define CURLYM 65 /* 0x41 Capture this medium-complex + thing {n,m} times. */ +#define CURLYM_tb_pb 260 /* 0x104 */ +#define CURLYM_tb_p8 261 /* 0x105 */ +#define CURLYM_t8_pb 262 /* 0x106 */ +#define CURLYM_t8_p8 263 /* 0x107 */ + +#define CURLYX 66 /* 0x42 Match this complex thing + {n,m} times. */ +#define CURLYX_tb_pb 264 /* 0x108 */ +#define CURLYX_tb_p8 265 /* 0x109 */ +#define CURLYX_t8_pb 266 /* 0x10a */ +#define CURLYX_t8_p8 267 /* 0x10b */ + +#define WHILEM 67 /* 0x43 Do curly processing and see + if rest matches. */ +#define WHILEM_tb_pb 268 /* 0x10c */ +#define WHILEM_tb_p8 269 /* 0x10d */ +#define WHILEM_t8_pb 270 /* 0x10e */ +#define WHILEM_t8_p8 271 /* 0x10f */ + +#define OPEN 68 /* 0x44 Mark this point in input as + start of #n. */ +#define OPEN_tb_pb 272 /* 0x110 */ +#define OPEN_tb_p8 273 /* 0x111 */ +#define OPEN_t8_pb 274 /* 0x112 */ +#define OPEN_t8_p8 275 /* 0x113 */ + +#define CLOSE 69 /* 0x45 Close corresponding OPEN of + #n. */ +#define CLOSE_tb_pb 276 /* 0x114 */ +#define CLOSE_tb_p8 277 /* 0x115 */ +#define CLOSE_t8_pb 278 /* 0x116 */ +#define CLOSE_t8_p8 279 /* 0x117 */ + +#define SROPEN 70 /* 0x46 Same as OPEN, but for + script run */ +#define SROPEN_tb_pb 280 /* 0x118 */ +#define SROPEN_tb_p8 281 /* 0x119 */ +#define SROPEN_t8_pb 282 /* 0x11a */ +#define SROPEN_t8_p8 283 /* 0x11b */ + +#define SRCLOSE 71 /* 0x47 Close preceding SROPEN */ +#define SRCLOSE_tb_pb 284 /* 0x11c */ +#define SRCLOSE_tb_p8 285 /* 0x11d */ +#define SRCLOSE_t8_pb 286 /* 0x11e */ +#define SRCLOSE_t8_p8 287 /* 0x11f */ + +#define REF 72 /* 0x48 Match some already matched + string */ +#define REF_tb_pb 288 /* 0x120 */ +#define REF_tb_p8 289 /* 0x121 */ +#define REF_t8_pb 290 /* 0x122 */ +#define REF_t8_p8 291 /* 0x123 */ + +#define REFF 73 /* 0x49 Match already matched + string, using /di rules. */ +#define REFF_tb_pb 292 /* 0x124 */ +#define REFF_tb_p8 293 /* 0x125 */ +#define REFF_t8_pb 294 /* 0x126 */ +#define REFF_t8_p8 295 /* 0x127 */ + +#define REFFL 74 /* 0x4a Match already matched + string, using /li rules. */ +#define REFFL_tb_pb 296 /* 0x128 */ +#define REFFL_tb_p8 297 /* 0x129 */ +#define REFFL_t8_pb 298 /* 0x12a */ +#define REFFL_t8_p8 299 /* 0x12b */ + +#define REFFU 75 /* 0x4b Match already matched + string, usng /ui. */ +#define REFFU_tb_pb 300 /* 0x12c */ +#define REFFU_tb_p8 301 /* 0x12d */ +#define REFFU_t8_pb 302 /* 0x12e */ +#define REFFU_t8_p8 303 /* 0x12f */ + +#define REFFA 76 /* 0x4c Match already matched + string, using /aai rules. */ +#define REFFA_tb_pb 304 /* 0x130 */ +#define REFFA_tb_p8 305 /* 0x131 */ +#define REFFA_t8_pb 306 /* 0x132 */ +#define REFFA_t8_p8 307 /* 0x133 */ + +#define REFN 77 /* 0x4d Match some already matched + string */ +#define REFN_tb_pb 308 /* 0x134 */ +#define REFN_tb_p8 309 /* 0x135 */ +#define REFN_t8_pb 310 /* 0x136 */ +#define REFN_t8_p8 311 /* 0x137 */ + +#define REFFN 78 /* 0x4e Match already matched + string, using /di rules. */ +#define REFFN_tb_pb 312 /* 0x138 */ +#define REFFN_tb_p8 313 /* 0x139 */ +#define REFFN_t8_pb 314 /* 0x13a */ +#define REFFN_t8_p8 315 /* 0x13b */ + +#define REFFLN 79 /* 0x4f Match already matched + string, using /li rules. */ +#define REFFLN_tb_pb 316 /* 0x13c */ +#define REFFLN_tb_p8 317 /* 0x13d */ +#define REFFLN_t8_pb 318 /* 0x13e */ +#define REFFLN_t8_p8 319 /* 0x13f */ + +#define REFFUN 80 /* 0x50 Match already matched + string, using /ui rules. */ +#define REFFUN_tb_pb 320 /* 0x140 */ +#define REFFUN_tb_p8 321 /* 0x141 */ +#define REFFUN_t8_pb 322 /* 0x142 */ +#define REFFUN_t8_p8 323 /* 0x143 */ + +#define REFFAN 81 /* 0x51 Match already matched + string, using /aai rules. */ +#define REFFAN_tb_pb 324 /* 0x144 */ +#define REFFAN_tb_p8 325 /* 0x145 */ +#define REFFAN_t8_pb 326 /* 0x146 */ +#define REFFAN_t8_p8 327 /* 0x147 */ + +#define LONGJMP 82 /* 0x52 Jump far away. */ +#define LONGJMP_tb_pb 328 /* 0x148 */ +#define LONGJMP_tb_p8 329 /* 0x149 */ +#define LONGJMP_t8_pb 330 /* 0x14a */ +#define LONGJMP_t8_p8 331 /* 0x14b */ + +#define BRANCHJ 83 /* 0x53 BRANCH with long offset. */ +#define BRANCHJ_tb_pb 332 /* 0x14c */ +#define BRANCHJ_tb_p8 333 /* 0x14d */ +#define BRANCHJ_t8_pb 334 /* 0x14e */ +#define BRANCHJ_t8_p8 335 /* 0x14f */ + +#define IFMATCH 84 /* 0x54 Succeeds if the following + matches; non-zero flags "f", + next_off "o" means lookbehind + assertion starting "f..(f-o)" + characters before current */ +#define IFMATCH_tb_pb 336 /* 0x150 */ +#define IFMATCH_tb_p8 337 /* 0x151 */ +#define IFMATCH_t8_pb 338 /* 0x152 */ +#define IFMATCH_t8_p8 339 /* 0x153 */ + +#define UNLESSM 85 /* 0x55 Fails if the following + matches; non-zero flags "f", + next_off "o" means lookbehind + assertion starting "f..(f-o)" + characters before current */ +#define UNLESSM_tb_pb 340 /* 0x154 */ +#define UNLESSM_tb_p8 341 /* 0x155 */ +#define UNLESSM_t8_pb 342 /* 0x156 */ +#define UNLESSM_t8_p8 343 /* 0x157 */ + +#define SUSPEND 86 /* 0x56 "Independent" sub-RE. */ +#define SUSPEND_tb_pb 344 /* 0x158 */ +#define SUSPEND_tb_p8 345 /* 0x159 */ +#define SUSPEND_t8_pb 346 /* 0x15a */ +#define SUSPEND_t8_p8 347 /* 0x15b */ + +#define IFTHEN 87 /* 0x57 Switch, should be preceded + by switcher. */ +#define IFTHEN_tb_pb 348 /* 0x15c */ +#define IFTHEN_tb_p8 349 /* 0x15d */ +#define IFTHEN_t8_pb 350 /* 0x15e */ +#define IFTHEN_t8_p8 351 /* 0x15f */ + +#define GROUPP 88 /* 0x58 Whether the group matched. + */ +#define GROUPP_tb_pb 352 /* 0x160 */ +#define GROUPP_tb_p8 353 /* 0x161 */ +#define GROUPP_t8_pb 354 /* 0x162 */ +#define GROUPP_t8_p8 355 /* 0x163 */ + +#define EVAL 89 /* 0x59 Execute some Perl code. */ +#define EVAL_tb_pb 356 /* 0x164 */ +#define EVAL_tb_p8 357 /* 0x165 */ +#define EVAL_t8_pb 358 /* 0x166 */ +#define EVAL_t8_p8 359 /* 0x167 */ + +#define MINMOD 90 /* 0x5a Next operator is not + greedy. */ +#define MINMOD_tb_pb 360 /* 0x168 */ +#define MINMOD_tb_p8 361 /* 0x169 */ +#define MINMOD_t8_pb 362 /* 0x16a */ +#define MINMOD_t8_p8 363 /* 0x16b */ + +#define LOGICAL 91 /* 0x5b Next opcode should set the + flag only. */ +#define LOGICAL_tb_pb 364 /* 0x16c */ +#define LOGICAL_tb_p8 365 /* 0x16d */ +#define LOGICAL_t8_pb 366 /* 0x16e */ +#define LOGICAL_t8_p8 367 /* 0x16f */ + +#define RENUM 92 /* 0x5c Group with independently + numbered parens. */ +#define RENUM_tb_pb 368 /* 0x170 */ +#define RENUM_tb_p8 369 /* 0x171 */ +#define RENUM_t8_pb 370 /* 0x172 */ +#define RENUM_t8_p8 371 /* 0x173 */ + +#define GOSUB 93 /* 0x5d recurse to paren arg1 at + (signed) ofs arg2 */ +#define GOSUB_tb_pb 372 /* 0x174 */ +#define GOSUB_tb_p8 373 /* 0x175 */ +#define GOSUB_t8_pb 374 /* 0x176 */ +#define GOSUB_t8_p8 375 /* 0x177 */ + +#define GROUPPN 94 /* 0x5e Whether the group matched. + */ +#define GROUPPN_tb_pb 376 /* 0x178 */ +#define GROUPPN_tb_p8 377 /* 0x179 */ +#define GROUPPN_t8_pb 378 /* 0x17a */ +#define GROUPPN_t8_p8 379 /* 0x17b */ + +#define INSUBP 95 /* 0x5f Whether we are in a + specific recurse. */ +#define INSUBP_tb_pb 380 /* 0x17c */ +#define INSUBP_tb_p8 381 /* 0x17d */ +#define INSUBP_t8_pb 382 /* 0x17e */ +#define INSUBP_t8_p8 383 /* 0x17f */ + +#define DEFINEP 96 /* 0x60 Never execute directly. */ +#define DEFINEP_tb_pb 384 /* 0x180 */ +#define DEFINEP_tb_p8 385 /* 0x181 */ +#define DEFINEP_t8_pb 386 /* 0x182 */ +#define DEFINEP_t8_p8 387 /* 0x183 */ + +#define ENDLIKE 97 /* 0x61 Used only for the type + field of verbs */ +#define ENDLIKE_tb_pb 388 /* 0x184 */ +#define ENDLIKE_tb_p8 389 /* 0x185 */ +#define ENDLIKE_t8_pb 390 /* 0x186 */ +#define ENDLIKE_t8_p8 391 /* 0x187 */ + +#define OPFAIL 98 /* 0x62 Same as (?!), but with verb + arg */ +#define OPFAIL_tb_pb 392 /* 0x188 */ +#define OPFAIL_tb_p8 393 /* 0x189 */ +#define OPFAIL_t8_pb 394 /* 0x18a */ +#define OPFAIL_t8_p8 395 /* 0x18b */ + +#define ACCEPT 99 /* 0x63 Accepts the current matched + string, with verbar */ +#define ACCEPT_tb_pb 396 /* 0x18c */ +#define ACCEPT_tb_p8 397 /* 0x18d */ +#define ACCEPT_t8_pb 398 /* 0x18e */ +#define ACCEPT_t8_p8 399 /* 0x18f */ + +#define VERB 100 /* 0x64 Used only for the type + field of verbs */ +#define VERB_tb_pb 400 /* 0x190 */ +#define VERB_tb_p8 401 /* 0x191 */ +#define VERB_t8_pb 402 /* 0x192 */ +#define VERB_t8_p8 403 /* 0x193 */ + +#define PRUNE 101 /* 0x65 Pattern fails at this + startpoint if no-backtracking + through this */ +#define PRUNE_tb_pb 404 /* 0x194 */ +#define PRUNE_tb_p8 405 /* 0x195 */ +#define PRUNE_t8_pb 406 /* 0x196 */ +#define PRUNE_t8_p8 407 /* 0x197 */ + +#define MARKPOINT 102 /* 0x66 Push the current location + for rollback by cut. */ +#define MARKPOINT_tb_pb 408 /* 0x198 */ +#define MARKPOINT_tb_p8 409 /* 0x199 */ +#define MARKPOINT_t8_pb 410 /* 0x19a */ +#define MARKPOINT_t8_p8 411 /* 0x19b */ + +#define SKIP 103 /* 0x67 On failure skip forward (to + the mark) before retrying */ +#define SKIP_tb_pb 412 /* 0x19c */ +#define SKIP_tb_p8 413 /* 0x19d */ +#define SKIP_t8_pb 414 /* 0x19e */ +#define SKIP_t8_p8 415 /* 0x19f */ + +#define COMMIT 104 /* 0x68 Pattern fails outright if + backtracking through this */ +#define COMMIT_tb_pb 416 /* 0x1a0 */ +#define COMMIT_tb_p8 417 /* 0x1a1 */ +#define COMMIT_t8_pb 418 /* 0x1a2 */ +#define COMMIT_t8_p8 419 /* 0x1a3 */ + +#define CUTGROUP 105 /* 0x69 On failure go to the next + alternation in the group */ +#define CUTGROUP_tb_pb 420 /* 0x1a4 */ +#define CUTGROUP_tb_p8 421 /* 0x1a5 */ +#define CUTGROUP_t8_pb 422 /* 0x1a6 */ +#define CUTGROUP_t8_p8 423 /* 0x1a7 */ + +#define KEEPS 106 /* 0x6a $& begins here. */ +#define KEEPS_tb_pb 424 /* 0x1a8 */ +#define KEEPS_tb_p8 425 /* 0x1a9 */ +#define KEEPS_t8_pb 426 /* 0x1aa */ +#define KEEPS_t8_p8 427 /* 0x1ab */ + +#define OPTIMIZED 107 /* 0x6b Placeholder for dump. */ +#define OPTIMIZED_tb_pb 428 /* 0x1ac */ +#define OPTIMIZED_tb_p8 429 /* 0x1ad */ +#define OPTIMIZED_t8_pb 430 /* 0x1ae */ +#define OPTIMIZED_t8_p8 431 /* 0x1af */ + +#define PSEUDO 108 /* 0x6c Pseudo opcode for internal + use. */ +#define PSEUDO_tb_pb 432 /* 0x1b0 */ +#define PSEUDO_tb_p8 433 /* 0x1b1 */ +#define PSEUDO_t8_pb 434 /* 0x1b2 */ +#define PSEUDO_t8_p8 435 /* 0x1b3 */ + +#define REGEX_SET 109 /* 0x6d Regex set, temporary node + used in pre-optimization + compilation */ +#define REGEX_SET_tb_pb 436 /* 0x1b4 */ +#define REGEX_SET_tb_p8 437 /* 0x1b5 */ +#define REGEX_SET_t8_pb 438 /* 0x1b6 */ +#define REGEX_SET_t8_p8 439 /* 0x1b7 */ + /* ------------ States ------------- */ -#define TRIE_next (REGNODE_MAX + 1) /* state for TRIE */ -#define TRIE_next_fail (REGNODE_MAX + 2) /* state for TRIE */ -#define EVAL_AB (REGNODE_MAX + 3) /* state for EVAL */ -#define EVAL_AB_fail (REGNODE_MAX + 4) /* state for EVAL */ -#define CURLYX_end (REGNODE_MAX + 5) /* state for CURLYX */ -#define CURLYX_end_fail (REGNODE_MAX + 6) /* state for CURLYX */ -#define WHILEM_A_pre (REGNODE_MAX + 7) /* state for WHILEM */ -#define WHILEM_A_pre_fail (REGNODE_MAX + 8) /* state for WHILEM */ -#define WHILEM_A_min (REGNODE_MAX + 9) /* state for WHILEM */ -#define WHILEM_A_min_fail (REGNODE_MAX + 10) /* state for WHILEM */ -#define WHILEM_A_max (REGNODE_MAX + 11) /* state for WHILEM */ -#define WHILEM_A_max_fail (REGNODE_MAX + 12) /* state for WHILEM */ -#define WHILEM_B_min (REGNODE_MAX + 13) /* state for WHILEM */ -#define WHILEM_B_min_fail (REGNODE_MAX + 14) /* state for WHILEM */ -#define WHILEM_B_max (REGNODE_MAX + 15) /* state for WHILEM */ -#define WHILEM_B_max_fail (REGNODE_MAX + 16) /* state for WHILEM */ -#define BRANCH_next (REGNODE_MAX + 17) /* state for BRANCH */ -#define BRANCH_next_fail (REGNODE_MAX + 18) /* state for BRANCH */ -#define CURLYM_A (REGNODE_MAX + 19) /* state for CURLYM */ -#define CURLYM_A_fail (REGNODE_MAX + 20) /* state for CURLYM */ -#define CURLYM_B (REGNODE_MAX + 21) /* state for CURLYM */ -#define CURLYM_B_fail (REGNODE_MAX + 22) /* state for CURLYM */ -#define IFMATCH_A (REGNODE_MAX + 23) /* state for IFMATCH */ -#define IFMATCH_A_fail (REGNODE_MAX + 24) /* state for IFMATCH */ -#define CURLY_B_min_known (REGNODE_MAX + 25) /* state for CURLY */ -#define CURLY_B_min_known_fail (REGNODE_MAX + 26) /* state for CURLY */ -#define CURLY_B_min (REGNODE_MAX + 27) /* state for CURLY */ -#define CURLY_B_min_fail (REGNODE_MAX + 28) /* state for CURLY */ -#define CURLY_B_max (REGNODE_MAX + 29) /* state for CURLY */ -#define CURLY_B_max_fail (REGNODE_MAX + 30) /* state for CURLY */ -#define COMMIT_next (REGNODE_MAX + 31) /* state for COMMIT */ -#define COMMIT_next_fail (REGNODE_MAX + 32) /* state for COMMIT */ -#define MARKPOINT_next (REGNODE_MAX + 33) /* state for MARKPOINT */ -#define MARKPOINT_next_fail (REGNODE_MAX + 34) /* state for MARKPOINT */ -#define SKIP_next (REGNODE_MAX + 35) /* state for SKIP */ -#define SKIP_next_fail (REGNODE_MAX + 36) /* state for SKIP */ -#define CUTGROUP_next (REGNODE_MAX + 37) /* state for CUTGROUP */ -#define CUTGROUP_next_fail (REGNODE_MAX + 38) /* state for CUTGROUP */ -#define KEEPS_next (REGNODE_MAX + 39) /* state for KEEPS */ -#define KEEPS_next_fail (REGNODE_MAX + 40) /* state for KEEPS */ +#define TRIE_next 110 /* 0x6e state for TRIE */ +#define TRIE_next_tb_pb 440 /* 0x1b8 */ +#define TRIE_next_tb_p8 441 /* 0x1b9 */ +#define TRIE_next_t8_pb 442 /* 0x1ba */ +#define TRIE_next_t8_p8 443 /* 0x1bb */ + +#define TRIE_next_fail 111 /* 0x6f state for TRIE */ +#define TRIE_next_fail_tb_pb 444 /* 0x1bc */ +#define TRIE_next_fail_tb_p8 445 /* 0x1bd */ +#define TRIE_next_fail_t8_pb 446 /* 0x1be */ +#define TRIE_next_fail_t8_p8 447 /* 0x1bf */ + +#define EVAL_B 112 /* 0x70 state for EVAL */ +#define EVAL_B_tb_pb 448 /* 0x1c0 */ +#define EVAL_B_tb_p8 449 /* 0x1c1 */ +#define EVAL_B_t8_pb 450 /* 0x1c2 */ +#define EVAL_B_t8_p8 451 /* 0x1c3 */ + +#define EVAL_B_fail 113 /* 0x71 state for EVAL */ +#define EVAL_B_fail_tb_pb 452 /* 0x1c4 */ +#define EVAL_B_fail_tb_p8 453 /* 0x1c5 */ +#define EVAL_B_fail_t8_pb 454 /* 0x1c6 */ +#define EVAL_B_fail_t8_p8 455 /* 0x1c7 */ + +#define EVAL_postponed_AB 114 /* 0x72 state for EVAL */ +#define EVAL_postponed_AB_tb_pb 456 /* 0x1c8 */ +#define EVAL_postponed_AB_tb_p8 457 /* 0x1c9 */ +#define EVAL_postponed_AB_t8_pb 458 /* 0x1ca */ +#define EVAL_postponed_AB_t8_p8 459 /* 0x1cb */ + +#define EVAL_postponed_AB_fail 115 /* 0x73 state for EVAL */ +#define EVAL_postponed_AB_fail_tb_pb 460 /* 0x1cc */ +#define EVAL_postponed_AB_fail_tb_p8 461 /* 0x1cd */ +#define EVAL_postponed_AB_fail_t8_pb 462 /* 0x1ce */ +#define EVAL_postponed_AB_fail_t8_p8 463 /* 0x1cf */ + +#define CURLYX_end 116 /* 0x74 state for CURLYX */ +#define CURLYX_end_tb_pb 464 /* 0x1d0 */ +#define CURLYX_end_tb_p8 465 /* 0x1d1 */ +#define CURLYX_end_t8_pb 466 /* 0x1d2 */ +#define CURLYX_end_t8_p8 467 /* 0x1d3 */ + +#define CURLYX_end_fail 117 /* 0x75 state for CURLYX */ +#define CURLYX_end_fail_tb_pb 468 /* 0x1d4 */ +#define CURLYX_end_fail_tb_p8 469 /* 0x1d5 */ +#define CURLYX_end_fail_t8_pb 470 /* 0x1d6 */ +#define CURLYX_end_fail_t8_p8 471 /* 0x1d7 */ + +#define WHILEM_A_pre 118 /* 0x76 state for WHILEM */ +#define WHILEM_A_pre_tb_pb 472 /* 0x1d8 */ +#define WHILEM_A_pre_tb_p8 473 /* 0x1d9 */ +#define WHILEM_A_pre_t8_pb 474 /* 0x1da */ +#define WHILEM_A_pre_t8_p8 475 /* 0x1db */ + +#define WHILEM_A_pre_fail 119 /* 0x77 state for WHILEM */ +#define WHILEM_A_pre_fail_tb_pb 476 /* 0x1dc */ +#define WHILEM_A_pre_fail_tb_p8 477 /* 0x1dd */ +#define WHILEM_A_pre_fail_t8_pb 478 /* 0x1de */ +#define WHILEM_A_pre_fail_t8_p8 479 /* 0x1df */ + +#define WHILEM_A_min 120 /* 0x78 state for WHILEM */ +#define WHILEM_A_min_tb_pb 480 /* 0x1e0 */ +#define WHILEM_A_min_tb_p8 481 /* 0x1e1 */ +#define WHILEM_A_min_t8_pb 482 /* 0x1e2 */ +#define WHILEM_A_min_t8_p8 483 /* 0x1e3 */ + +#define WHILEM_A_min_fail 121 /* 0x79 state for WHILEM */ +#define WHILEM_A_min_fail_tb_pb 484 /* 0x1e4 */ +#define WHILEM_A_min_fail_tb_p8 485 /* 0x1e5 */ +#define WHILEM_A_min_fail_t8_pb 486 /* 0x1e6 */ +#define WHILEM_A_min_fail_t8_p8 487 /* 0x1e7 */ + +#define WHILEM_A_max 122 /* 0x7a state for WHILEM */ +#define WHILEM_A_max_tb_pb 488 /* 0x1e8 */ +#define WHILEM_A_max_tb_p8 489 /* 0x1e9 */ +#define WHILEM_A_max_t8_pb 490 /* 0x1ea */ +#define WHILEM_A_max_t8_p8 491 /* 0x1eb */ + +#define WHILEM_A_max_fail 123 /* 0x7b state for WHILEM */ +#define WHILEM_A_max_fail_tb_pb 492 /* 0x1ec */ +#define WHILEM_A_max_fail_tb_p8 493 /* 0x1ed */ +#define WHILEM_A_max_fail_t8_pb 494 /* 0x1ee */ +#define WHILEM_A_max_fail_t8_p8 495 /* 0x1ef */ + +#define WHILEM_B_min 124 /* 0x7c state for WHILEM */ +#define WHILEM_B_min_tb_pb 496 /* 0x1f0 */ +#define WHILEM_B_min_tb_p8 497 /* 0x1f1 */ +#define WHILEM_B_min_t8_pb 498 /* 0x1f2 */ +#define WHILEM_B_min_t8_p8 499 /* 0x1f3 */ + +#define WHILEM_B_min_fail 125 /* 0x7d state for WHILEM */ +#define WHILEM_B_min_fail_tb_pb 500 /* 0x1f4 */ +#define WHILEM_B_min_fail_tb_p8 501 /* 0x1f5 */ +#define WHILEM_B_min_fail_t8_pb 502 /* 0x1f6 */ +#define WHILEM_B_min_fail_t8_p8 503 /* 0x1f7 */ + +#define WHILEM_B_max 126 /* 0x7e state for WHILEM */ +#define WHILEM_B_max_tb_pb 504 /* 0x1f8 */ +#define WHILEM_B_max_tb_p8 505 /* 0x1f9 */ +#define WHILEM_B_max_t8_pb 506 /* 0x1fa */ +#define WHILEM_B_max_t8_p8 507 /* 0x1fb */ + +#define WHILEM_B_max_fail 127 /* 0x7f state for WHILEM */ +#define WHILEM_B_max_fail_tb_pb 508 /* 0x1fc */ +#define WHILEM_B_max_fail_tb_p8 509 /* 0x1fd */ +#define WHILEM_B_max_fail_t8_pb 510 /* 0x1fe */ +#define WHILEM_B_max_fail_t8_p8 511 /* 0x1ff */ + +#define BRANCH_next 128 /* 0x80 state for BRANCH */ +#define BRANCH_next_tb_pb 512 /* 0x200 */ +#define BRANCH_next_tb_p8 513 /* 0x201 */ +#define BRANCH_next_t8_pb 514 /* 0x202 */ +#define BRANCH_next_t8_p8 515 /* 0x203 */ + +#define BRANCH_next_fail 129 /* 0x81 state for BRANCH */ +#define BRANCH_next_fail_tb_pb 516 /* 0x204 */ +#define BRANCH_next_fail_tb_p8 517 /* 0x205 */ +#define BRANCH_next_fail_t8_pb 518 /* 0x206 */ +#define BRANCH_next_fail_t8_p8 519 /* 0x207 */ + +#define CURLYM_A 130 /* 0x82 state for CURLYM */ +#define CURLYM_A_tb_pb 520 /* 0x208 */ +#define CURLYM_A_tb_p8 521 /* 0x209 */ +#define CURLYM_A_t8_pb 522 /* 0x20a */ +#define CURLYM_A_t8_p8 523 /* 0x20b */ + +#define CURLYM_A_fail 131 /* 0x83 state for CURLYM */ +#define CURLYM_A_fail_tb_pb 524 /* 0x20c */ +#define CURLYM_A_fail_tb_p8 525 /* 0x20d */ +#define CURLYM_A_fail_t8_pb 526 /* 0x20e */ +#define CURLYM_A_fail_t8_p8 527 /* 0x20f */ + +#define CURLYM_B 132 /* 0x84 state for CURLYM */ +#define CURLYM_B_tb_pb 528 /* 0x210 */ +#define CURLYM_B_tb_p8 529 /* 0x211 */ +#define CURLYM_B_t8_pb 530 /* 0x212 */ +#define CURLYM_B_t8_p8 531 /* 0x213 */ + +#define CURLYM_B_fail 133 /* 0x85 state for CURLYM */ +#define CURLYM_B_fail_tb_pb 532 /* 0x214 */ +#define CURLYM_B_fail_tb_p8 533 /* 0x215 */ +#define CURLYM_B_fail_t8_pb 534 /* 0x216 */ +#define CURLYM_B_fail_t8_p8 535 /* 0x217 */ + +#define IFMATCH_A 134 /* 0x86 state for IFMATCH */ +#define IFMATCH_A_tb_pb 536 /* 0x218 */ +#define IFMATCH_A_tb_p8 537 /* 0x219 */ +#define IFMATCH_A_t8_pb 538 /* 0x21a */ +#define IFMATCH_A_t8_p8 539 /* 0x21b */ + +#define IFMATCH_A_fail 135 /* 0x87 state for IFMATCH */ +#define IFMATCH_A_fail_tb_pb 540 /* 0x21c */ +#define IFMATCH_A_fail_tb_p8 541 /* 0x21d */ +#define IFMATCH_A_fail_t8_pb 542 /* 0x21e */ +#define IFMATCH_A_fail_t8_p8 543 /* 0x21f */ + +#define CURLY_B_min 136 /* 0x88 state for CURLY */ +#define CURLY_B_min_tb_pb 544 /* 0x220 */ +#define CURLY_B_min_tb_p8 545 /* 0x221 */ +#define CURLY_B_min_t8_pb 546 /* 0x222 */ +#define CURLY_B_min_t8_p8 547 /* 0x223 */ + +#define CURLY_B_min_fail 137 /* 0x89 state for CURLY */ +#define CURLY_B_min_fail_tb_pb 548 /* 0x224 */ +#define CURLY_B_min_fail_tb_p8 549 /* 0x225 */ +#define CURLY_B_min_fail_t8_pb 550 /* 0x226 */ +#define CURLY_B_min_fail_t8_p8 551 /* 0x227 */ + +#define CURLY_B_max 138 /* 0x8a state for CURLY */ +#define CURLY_B_max_tb_pb 552 /* 0x228 */ +#define CURLY_B_max_tb_p8 553 /* 0x229 */ +#define CURLY_B_max_t8_pb 554 /* 0x22a */ +#define CURLY_B_max_t8_p8 555 /* 0x22b */ + +#define CURLY_B_max_fail 139 /* 0x8b state for CURLY */ +#define CURLY_B_max_fail_tb_pb 556 /* 0x22c */ +#define CURLY_B_max_fail_tb_p8 557 /* 0x22d */ +#define CURLY_B_max_fail_t8_pb 558 /* 0x22e */ +#define CURLY_B_max_fail_t8_p8 559 /* 0x22f */ + +#define COMMIT_next 140 /* 0x8c state for COMMIT */ +#define COMMIT_next_tb_pb 560 /* 0x230 */ +#define COMMIT_next_tb_p8 561 /* 0x231 */ +#define COMMIT_next_t8_pb 562 /* 0x232 */ +#define COMMIT_next_t8_p8 563 /* 0x233 */ + +#define COMMIT_next_fail 141 /* 0x8d state for COMMIT */ +#define COMMIT_next_fail_tb_pb 564 /* 0x234 */ +#define COMMIT_next_fail_tb_p8 565 /* 0x235 */ +#define COMMIT_next_fail_t8_pb 566 /* 0x236 */ +#define COMMIT_next_fail_t8_p8 567 /* 0x237 */ + +#define MARKPOINT_next 142 /* 0x8e state for MARKPOINT */ +#define MARKPOINT_next_tb_pb 568 /* 0x238 */ +#define MARKPOINT_next_tb_p8 569 /* 0x239 */ +#define MARKPOINT_next_t8_pb 570 /* 0x23a */ +#define MARKPOINT_next_t8_p8 571 /* 0x23b */ + +#define MARKPOINT_next_fail 143 /* 0x8f state for MARKPOINT */ +#define MARKPOINT_next_fail_tb_pb 572 /* 0x23c */ +#define MARKPOINT_next_fail_tb_p8 573 /* 0x23d */ +#define MARKPOINT_next_fail_t8_pb 574 /* 0x23e */ +#define MARKPOINT_next_fail_t8_p8 575 /* 0x23f */ + +#define SKIP_next 144 /* 0x90 state for SKIP */ +#define SKIP_next_tb_pb 576 /* 0x240 */ +#define SKIP_next_tb_p8 577 /* 0x241 */ +#define SKIP_next_t8_pb 578 /* 0x242 */ +#define SKIP_next_t8_p8 579 /* 0x243 */ + +#define SKIP_next_fail 145 /* 0x91 state for SKIP */ +#define SKIP_next_fail_tb_pb 580 /* 0x244 */ +#define SKIP_next_fail_tb_p8 581 /* 0x245 */ +#define SKIP_next_fail_t8_pb 582 /* 0x246 */ +#define SKIP_next_fail_t8_p8 583 /* 0x247 */ + +#define CUTGROUP_next 146 /* 0x92 state for CUTGROUP */ +#define CUTGROUP_next_tb_pb 584 /* 0x248 */ +#define CUTGROUP_next_tb_p8 585 /* 0x249 */ +#define CUTGROUP_next_t8_pb 586 /* 0x24a */ +#define CUTGROUP_next_t8_p8 587 /* 0x24b */ + +#define CUTGROUP_next_fail 147 /* 0x93 state for CUTGROUP */ +#define CUTGROUP_next_fail_tb_pb 588 /* 0x24c */ +#define CUTGROUP_next_fail_tb_p8 589 /* 0x24d */ +#define CUTGROUP_next_fail_t8_pb 590 /* 0x24e */ +#define CUTGROUP_next_fail_t8_p8 591 /* 0x24f */ + +#define KEEPS_next 148 /* 0x94 state for KEEPS */ +#define KEEPS_next_tb_pb 592 /* 0x250 */ +#define KEEPS_next_tb_p8 593 /* 0x251 */ +#define KEEPS_next_t8_pb 594 /* 0x252 */ +#define KEEPS_next_t8_p8 595 /* 0x253 */ + +#define KEEPS_next_fail 149 /* 0x95 state for KEEPS */ +#define KEEPS_next_fail_tb_pb 596 /* 0x254 */ +#define KEEPS_next_fail_tb_p8 597 /* 0x255 */ +#define KEEPS_next_fail_t8_pb 598 /* 0x256 */ +#define KEEPS_next_fail_t8_p8 599 /* 0x257 */ + /* PL_regkind[] What type of regop or state is this. */ @@ -174,13 +1091,12 @@ EXTCONST U8 PL_regkind[]; EXTCONST U8 PL_regkind[] = { END, /* END */ END, /* SUCCEED */ - BOL, /* BOL */ - BOL, /* MBOL */ BOL, /* SBOL */ - EOL, /* EOS */ - EOL, /* EOL */ - EOL, /* MEOL */ + BOL, /* MBOL */ EOL, /* SEOL */ + EOL, /* MEOL */ + EOL, /* EOS */ + GPOS, /* GPOS */ BOUND, /* BOUND */ BOUND, /* BOUNDL */ BOUND, /* BOUNDU */ @@ -189,46 +1105,49 @@ EXTCONST U8 PL_regkind[] = { NBOUND, /* NBOUNDL */ NBOUND, /* NBOUNDU */ NBOUND, /* NBOUNDA */ - GPOS, /* GPOS */ REG_ANY, /* REG_ANY */ REG_ANY, /* SANY */ - REG_ANY, /* CANY */ ANYOF, /* ANYOF */ - ANYOF, /* ANYOFV */ - ALNUM, /* ALNUM */ - ALNUM, /* ALNUML */ - ALNUM, /* ALNUMU */ - ALNUM, /* ALNUMA */ - NALNUM, /* NALNUM */ - NALNUM, /* NALNUML */ - NALNUM, /* NALNUMU */ - NALNUM, /* NALNUMA */ - SPACE, /* SPACE */ - SPACE, /* SPACEL */ - SPACE, /* SPACEU */ - SPACE, /* SPACEA */ - NSPACE, /* NSPACE */ - NSPACE, /* NSPACEL */ - NSPACE, /* NSPACEU */ - NSPACE, /* NSPACEA */ - DIGIT, /* DIGIT */ - DIGIT, /* DIGITL */ - NOTHING, /* PLACEHOLDER1 */ - DIGIT, /* DIGITA */ - NDIGIT, /* NDIGIT */ - NDIGIT, /* NDIGITL */ - NOTHING, /* PLACEHOLDER2 */ - NDIGIT, /* NDIGITA */ + ANYOF, /* ANYOFD */ + ANYOF, /* ANYOFL */ + ANYOF, /* ANYOFPOSIXL */ + ANYOF, /* ANYOFH */ + ANYOF, /* ANYOFHb */ + ANYOF, /* ANYOFHr */ + ANYOF, /* ANYOFHs */ + ANYOFR, /* ANYOFR */ + ANYOFR, /* ANYOFRb */ + ANYOFM, /* ANYOFM */ + ANYOFM, /* NANYOFM */ + POSIXD, /* POSIXD */ + POSIXD, /* POSIXL */ + POSIXD, /* POSIXU */ + POSIXD, /* POSIXA */ + NPOSIXD, /* NPOSIXD */ + NPOSIXD, /* NPOSIXL */ + NPOSIXD, /* NPOSIXU */ + NPOSIXD, /* NPOSIXA */ CLUMP, /* CLUMP */ BRANCH, /* BRANCH */ - BACK, /* BACK */ EXACT, /* EXACT */ + EXACT, /* LEXACT */ + EXACT, /* EXACTL */ EXACT, /* EXACTF */ EXACT, /* EXACTFL */ EXACT, /* EXACTFU */ - EXACT, /* EXACTFA */ - EXACT, /* EXACTFU_SS */ - EXACT, /* EXACTFU_TRICKYFOLD */ + EXACT, /* EXACTFAA */ + EXACT, /* EXACTFAA_NO_TRIE */ + EXACT, /* EXACTFUP */ + EXACT, /* EXACTFLU8 */ + EXACT, /* EXACT_REQ8 */ + EXACT, /* LEXACT_REQ8 */ + EXACT, /* EXACTFU_REQ8 */ + EXACT, /* EXACTFU_S_EDGE */ + LNBREAK, /* LNBREAK */ + TRIE, /* TRIE */ + TRIE, /* TRIEC */ + TRIE, /* AHOCORASICK */ + TRIE, /* AHOCORASICKC */ NOTHING, /* NOTHING */ NOTHING, /* TAIL */ STAR, /* STAR */ @@ -240,34 +1159,31 @@ EXTCONST U8 PL_regkind[] = { WHILEM, /* WHILEM */ OPEN, /* OPEN */ CLOSE, /* CLOSE */ + SROPEN, /* SROPEN */ + SRCLOSE, /* SRCLOSE */ REF, /* REF */ REF, /* REFF */ REF, /* REFFL */ REF, /* REFFU */ REF, /* REFFA */ - REF, /* NREF */ - REF, /* NREFF */ - REF, /* NREFFL */ - REF, /* NREFFU */ - REF, /* NREFFA */ + REF, /* REFN */ + REF, /* REFFN */ + REF, /* REFFLN */ + REF, /* REFFUN */ + REF, /* REFFAN */ + LONGJMP, /* LONGJMP */ + BRANCHJ, /* BRANCHJ */ 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 */ GOSUB, /* GOSUB */ - GOSTART, /* GOSTART */ - NGROUPP, /* NGROUPP */ + GROUPPN, /* GROUPPN */ INSUBP, /* INSUBP */ DEFINEP, /* DEFINEP */ ENDLIKE, /* ENDLIKE */ @@ -280,18 +1196,16 @@ EXTCONST U8 PL_regkind[] = { VERB, /* COMMIT */ VERB, /* CUTGROUP */ KEEPS, /* KEEPS */ - LNBREAK, /* LNBREAK */ - VERTWS, /* VERTWS */ - NVERTWS, /* NVERTWS */ - HORIZWS, /* HORIZWS */ - NHORIZWS, /* NHORIZWS */ NOTHING, /* OPTIMIZED */ PSEUDO, /* PSEUDO */ + REGEX_SET, /* REGEX_SET */ /* ------------ States ------------- */ TRIE, /* TRIE_next */ TRIE, /* TRIE_next_fail */ - EVAL, /* EVAL_AB */ - EVAL, /* EVAL_AB_fail */ + EVAL, /* EVAL_B */ + EVAL, /* EVAL_B_fail */ + EVAL, /* EVAL_postponed_AB */ + EVAL, /* EVAL_postponed_AB_fail */ CURLYX, /* CURLYX_end */ CURLYX, /* CURLYX_end_fail */ WHILEM, /* WHILEM_A_pre */ @@ -312,8 +1226,6 @@ EXTCONST U8 PL_regkind[] = { 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 */ @@ -331,19 +1243,19 @@ EXTCONST U8 PL_regkind[] = { }; #endif +#ifdef REG_COMP_C + /* regarglen[] - How large is the argument part of the node (in regnodes) */ -#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, /* MBOL */ 0, /* SEOL */ + 0, /* MEOL */ + 0, /* EOS */ + 0, /* GPOS */ 0, /* BOUND */ 0, /* BOUNDL */ 0, /* BOUNDU */ @@ -352,46 +1264,49 @@ static const U8 regarglen[] = { 0, /* NBOUNDL */ 0, /* NBOUNDU */ 0, /* NBOUNDA */ - 0, /* GPOS */ 0, /* REG_ANY */ 0, /* SANY */ - 0, /* CANY */ - 0, /* ANYOF */ - 0, /* ANYOFV */ - 0, /* ALNUM */ - 0, /* ALNUML */ - 0, /* ALNUMU */ - 0, /* ALNUMA */ - 0, /* NALNUM */ - 0, /* NALNUML */ - 0, /* NALNUMU */ - 0, /* NALNUMA */ - 0, /* SPACE */ - 0, /* SPACEL */ - 0, /* SPACEU */ - 0, /* SPACEA */ - 0, /* NSPACE */ - 0, /* NSPACEL */ - 0, /* NSPACEU */ - 0, /* NSPACEA */ - 0, /* DIGIT */ - 0, /* DIGITL */ - 0, /* PLACEHOLDER1 */ - 0, /* DIGITA */ - 0, /* NDIGIT */ - 0, /* NDIGITL */ - 0, /* PLACEHOLDER2 */ - 0, /* NDIGITA */ + EXTRA_SIZE(struct regnode_charclass), /* ANYOF */ + EXTRA_SIZE(struct regnode_charclass), /* ANYOFD */ + EXTRA_SIZE(struct regnode_charclass), /* ANYOFL */ + EXTRA_SIZE(struct regnode_charclass_posixl), /* ANYOFPOSIXL */ + EXTRA_SIZE(struct regnode_1), /* ANYOFH */ + EXTRA_SIZE(struct regnode_1), /* ANYOFHb */ + EXTRA_SIZE(struct regnode_1), /* ANYOFHr */ + EXTRA_SIZE(struct regnode_1), /* ANYOFHs */ + EXTRA_SIZE(struct regnode_1), /* ANYOFR */ + EXTRA_SIZE(struct regnode_1), /* ANYOFRb */ + EXTRA_SIZE(struct regnode_1), /* ANYOFM */ + EXTRA_SIZE(struct regnode_1), /* NANYOFM */ + 0, /* POSIXD */ + 0, /* POSIXL */ + 0, /* POSIXU */ + 0, /* POSIXA */ + 0, /* NPOSIXD */ + 0, /* NPOSIXL */ + 0, /* NPOSIXU */ + 0, /* NPOSIXA */ 0, /* CLUMP */ 0, /* BRANCH */ - 0, /* BACK */ 0, /* EXACT */ + EXTRA_SIZE(struct regnode_1), /* LEXACT */ + 0, /* EXACTL */ 0, /* EXACTF */ 0, /* EXACTFL */ 0, /* EXACTFU */ - 0, /* EXACTFA */ - 0, /* EXACTFU_SS */ - 0, /* EXACTFU_TRICKYFOLD */ + 0, /* EXACTFAA */ + 0, /* EXACTFAA_NO_TRIE */ + 0, /* EXACTFUP */ + 0, /* EXACTFLU8 */ + 0, /* EXACT_REQ8 */ + EXTRA_SIZE(struct regnode_1), /* LEXACT_REQ8 */ + 0, /* EXACTFU_REQ8 */ + 0, /* EXACTFU_S_EDGE */ + 0, /* LNBREAK */ + 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, /* NOTHING */ 0, /* TAIL */ 0, /* STAR */ @@ -403,39 +1318,36 @@ static const U8 regarglen[] = { 0, /* WHILEM */ EXTRA_SIZE(struct regnode_1), /* OPEN */ EXTRA_SIZE(struct regnode_1), /* CLOSE */ + 0, /* SROPEN */ + 0, /* SRCLOSE */ EXTRA_SIZE(struct regnode_1), /* REF */ EXTRA_SIZE(struct regnode_1), /* REFF */ EXTRA_SIZE(struct regnode_1), /* REFFL */ EXTRA_SIZE(struct regnode_1), /* REFFU */ EXTRA_SIZE(struct regnode_1), /* REFFA */ - EXTRA_SIZE(struct regnode_1), /* NREF */ - EXTRA_SIZE(struct regnode_1), /* NREFF */ - EXTRA_SIZE(struct regnode_1), /* NREFFL */ - EXTRA_SIZE(struct regnode_1), /* NREFFU */ - EXTRA_SIZE(struct regnode_1), /* NREFFA */ + EXTRA_SIZE(struct regnode_1), /* REFN */ + EXTRA_SIZE(struct regnode_1), /* REFFN */ + EXTRA_SIZE(struct regnode_1), /* REFFLN */ + EXTRA_SIZE(struct regnode_1), /* REFFUN */ + EXTRA_SIZE(struct regnode_1), /* REFFAN */ + EXTRA_SIZE(struct regnode_1), /* LONGJMP */ + EXTRA_SIZE(struct regnode_1), /* BRANCHJ */ 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 */ + EXTRA_SIZE(struct regnode_2L), /* 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 */ EXTRA_SIZE(struct regnode_2L), /* GOSUB */ - 0, /* GOSTART */ - EXTRA_SIZE(struct regnode_1), /* NGROUPP */ + EXTRA_SIZE(struct regnode_1), /* GROUPPN */ EXTRA_SIZE(struct regnode_1), /* INSUBP */ EXTRA_SIZE(struct regnode_1), /* DEFINEP */ 0, /* ENDLIKE */ - 0, /* OPFAIL */ - EXTRA_SIZE(struct regnode_1), /* ACCEPT */ + EXTRA_SIZE(struct regnode_1), /* OPFAIL */ + EXTRA_SIZE(struct regnode_2L), /* ACCEPT */ EXTRA_SIZE(struct regnode_1), /* VERB */ EXTRA_SIZE(struct regnode_1), /* PRUNE */ EXTRA_SIZE(struct regnode_1), /* MARKPOINT */ @@ -443,13 +1355,9 @@ static const U8 regarglen[] = { EXTRA_SIZE(struct regnode_1), /* COMMIT */ EXTRA_SIZE(struct regnode_1), /* CUTGROUP */ 0, /* KEEPS */ - 0, /* LNBREAK */ - 0, /* VERTWS */ - 0, /* NVERTWS */ - 0, /* HORIZWS */ - 0, /* NHORIZWS */ 0, /* OPTIMIZED */ 0, /* PSEUDO */ + EXTRA_SIZE(struct regnode_p), /* REGEX_SET */ }; /* reg_off_by_arg[] - Which argument holds the offset to the next node */ @@ -457,13 +1365,12 @@ static const U8 regarglen[] = { static const char reg_off_by_arg[] = { 0, /* END */ 0, /* SUCCEED */ - 0, /* BOL */ - 0, /* MBOL */ 0, /* SBOL */ - 0, /* EOS */ - 0, /* EOL */ - 0, /* MEOL */ + 0, /* MBOL */ 0, /* SEOL */ + 0, /* MEOL */ + 0, /* EOS */ + 0, /* GPOS */ 0, /* BOUND */ 0, /* BOUNDL */ 0, /* BOUNDU */ @@ -472,46 +1379,49 @@ static const char reg_off_by_arg[] = { 0, /* NBOUNDL */ 0, /* NBOUNDU */ 0, /* NBOUNDA */ - 0, /* GPOS */ 0, /* REG_ANY */ 0, /* SANY */ - 0, /* CANY */ 0, /* ANYOF */ - 0, /* ANYOFV */ - 0, /* ALNUM */ - 0, /* ALNUML */ - 0, /* ALNUMU */ - 0, /* ALNUMA */ - 0, /* NALNUM */ - 0, /* NALNUML */ - 0, /* NALNUMU */ - 0, /* NALNUMA */ - 0, /* SPACE */ - 0, /* SPACEL */ - 0, /* SPACEU */ - 0, /* SPACEA */ - 0, /* NSPACE */ - 0, /* NSPACEL */ - 0, /* NSPACEU */ - 0, /* NSPACEA */ - 0, /* DIGIT */ - 0, /* DIGITL */ - 0, /* PLACEHOLDER1 */ - 0, /* DIGITA */ - 0, /* NDIGIT */ - 0, /* NDIGITL */ - 0, /* PLACEHOLDER2 */ - 0, /* NDIGITA */ + 0, /* ANYOFD */ + 0, /* ANYOFL */ + 0, /* ANYOFPOSIXL */ + 0, /* ANYOFH */ + 0, /* ANYOFHb */ + 0, /* ANYOFHr */ + 0, /* ANYOFHs */ + 0, /* ANYOFR */ + 0, /* ANYOFRb */ + 0, /* ANYOFM */ + 0, /* NANYOFM */ + 0, /* POSIXD */ + 0, /* POSIXL */ + 0, /* POSIXU */ + 0, /* POSIXA */ + 0, /* NPOSIXD */ + 0, /* NPOSIXL */ + 0, /* NPOSIXU */ + 0, /* NPOSIXA */ 0, /* CLUMP */ 0, /* BRANCH */ - 0, /* BACK */ 0, /* EXACT */ + 0, /* LEXACT */ + 0, /* EXACTL */ 0, /* EXACTF */ 0, /* EXACTFL */ 0, /* EXACTFU */ - 0, /* EXACTFA */ - 0, /* EXACTFU_SS */ - 0, /* EXACTFU_TRICKYFOLD */ + 0, /* EXACTFAA */ + 0, /* EXACTFAA_NO_TRIE */ + 0, /* EXACTFUP */ + 0, /* EXACTFLU8 */ + 0, /* EXACT_REQ8 */ + 0, /* LEXACT_REQ8 */ + 0, /* EXACTFU_REQ8 */ + 0, /* EXACTFU_S_EDGE */ + 0, /* LNBREAK */ + 0, /* TRIE */ + 0, /* TRIEC */ + 0, /* AHOCORASICK */ + 0, /* AHOCORASICKC */ 0, /* NOTHING */ 0, /* TAIL */ 0, /* STAR */ @@ -523,34 +1433,31 @@ static const char reg_off_by_arg[] = { 0, /* WHILEM */ 0, /* OPEN */ 0, /* CLOSE */ + 0, /* SROPEN */ + 0, /* SRCLOSE */ 0, /* REF */ 0, /* REFF */ 0, /* REFFL */ 0, /* REFFU */ 0, /* REFFA */ - 0, /* NREF */ - 0, /* NREFF */ - 0, /* NREFFL */ - 0, /* NREFFU */ - 0, /* NREFFA */ - 2, /* IFMATCH */ - 2, /* UNLESSM */ + 0, /* REFN */ + 0, /* REFFN */ + 0, /* REFFLN */ + 0, /* REFFUN */ + 0, /* REFFAN */ + 1, /* LONGJMP */ + 1, /* BRANCHJ */ + 1, /* IFMATCH */ + 1, /* 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, /* GOSUB */ - 0, /* GOSTART */ - 0, /* NGROUPP */ + 0, /* GROUPPN */ 0, /* INSUBP */ 0, /* DEFINEP */ 0, /* ENDLIKE */ @@ -563,17 +1470,14 @@ static const char reg_off_by_arg[] = { 0, /* COMMIT */ 0, /* CUTGROUP */ 0, /* KEEPS */ - 0, /* LNBREAK */ - 0, /* VERTWS */ - 0, /* NVERTWS */ - 0, /* HORIZWS */ - 0, /* NHORIZWS */ 0, /* OPTIMIZED */ 0, /* PSEUDO */ + 0, /* REGEX_SET */ }; #endif /* REG_COMP_C */ + /* reg_name[] - Opcode/state names in string form, for debugging */ #ifndef DOINIT @@ -582,146 +1486,141 @@ EXTCONST char * PL_reg_name[]; EXTCONST char * const PL_reg_name[] = { "END", /* 0000 */ "SUCCEED", /* 0x01 */ - "BOL", /* 0x02 */ + "SBOL", /* 0x02 */ "MBOL", /* 0x03 */ - "SBOL", /* 0x04 */ - "EOS", /* 0x05 */ - "EOL", /* 0x06 */ - "MEOL", /* 0x07 */ - "SEOL", /* 0x08 */ - "BOUND", /* 0x09 */ - "BOUNDL", /* 0x0a */ - "BOUNDU", /* 0x0b */ - "BOUNDA", /* 0x0c */ - "NBOUND", /* 0x0d */ - "NBOUNDL", /* 0x0e */ - "NBOUNDU", /* 0x0f */ - "NBOUNDA", /* 0x10 */ - "GPOS", /* 0x11 */ - "REG_ANY", /* 0x12 */ - "SANY", /* 0x13 */ - "CANY", /* 0x14 */ - "ANYOF", /* 0x15 */ - "ANYOFV", /* 0x16 */ - "ALNUM", /* 0x17 */ - "ALNUML", /* 0x18 */ - "ALNUMU", /* 0x19 */ - "ALNUMA", /* 0x1a */ - "NALNUM", /* 0x1b */ - "NALNUML", /* 0x1c */ - "NALNUMU", /* 0x1d */ - "NALNUMA", /* 0x1e */ - "SPACE", /* 0x1f */ - "SPACEL", /* 0x20 */ - "SPACEU", /* 0x21 */ - "SPACEA", /* 0x22 */ - "NSPACE", /* 0x23 */ - "NSPACEL", /* 0x24 */ - "NSPACEU", /* 0x25 */ - "NSPACEA", /* 0x26 */ - "DIGIT", /* 0x27 */ - "DIGITL", /* 0x28 */ - "PLACEHOLDER1", /* 0x29 */ - "DIGITA", /* 0x2a */ - "NDIGIT", /* 0x2b */ - "NDIGITL", /* 0x2c */ - "PLACEHOLDER2", /* 0x2d */ - "NDIGITA", /* 0x2e */ - "CLUMP", /* 0x2f */ - "BRANCH", /* 0x30 */ - "BACK", /* 0x31 */ - "EXACT", /* 0x32 */ - "EXACTF", /* 0x33 */ - "EXACTFL", /* 0x34 */ - "EXACTFU", /* 0x35 */ - "EXACTFA", /* 0x36 */ - "EXACTFU_SS", /* 0x37 */ - "EXACTFU_TRICKYFOLD", /* 0x38 */ - "NOTHING", /* 0x39 */ - "TAIL", /* 0x3a */ - "STAR", /* 0x3b */ - "PLUS", /* 0x3c */ - "CURLY", /* 0x3d */ - "CURLYN", /* 0x3e */ - "CURLYM", /* 0x3f */ - "CURLYX", /* 0x40 */ - "WHILEM", /* 0x41 */ - "OPEN", /* 0x42 */ - "CLOSE", /* 0x43 */ - "REF", /* 0x44 */ - "REFF", /* 0x45 */ - "REFFL", /* 0x46 */ - "REFFU", /* 0x47 */ - "REFFA", /* 0x48 */ - "NREF", /* 0x49 */ - "NREFF", /* 0x4a */ - "NREFFL", /* 0x4b */ - "NREFFU", /* 0x4c */ - "NREFFA", /* 0x4d */ - "IFMATCH", /* 0x4e */ - "UNLESSM", /* 0x4f */ - "SUSPEND", /* 0x50 */ - "IFTHEN", /* 0x51 */ - "GROUPP", /* 0x52 */ - "LONGJMP", /* 0x53 */ - "BRANCHJ", /* 0x54 */ - "EVAL", /* 0x55 */ - "MINMOD", /* 0x56 */ - "LOGICAL", /* 0x57 */ - "RENUM", /* 0x58 */ - "TRIE", /* 0x59 */ - "TRIEC", /* 0x5a */ - "AHOCORASICK", /* 0x5b */ - "AHOCORASICKC", /* 0x5c */ + "SEOL", /* 0x04 */ + "MEOL", /* 0x05 */ + "EOS", /* 0x06 */ + "GPOS", /* 0x07 */ + "BOUND", /* 0x08 */ + "BOUNDL", /* 0x09 */ + "BOUNDU", /* 0x0a */ + "BOUNDA", /* 0x0b */ + "NBOUND", /* 0x0c */ + "NBOUNDL", /* 0x0d */ + "NBOUNDU", /* 0x0e */ + "NBOUNDA", /* 0x0f */ + "REG_ANY", /* 0x10 */ + "SANY", /* 0x11 */ + "ANYOF", /* 0x12 */ + "ANYOFD", /* 0x13 */ + "ANYOFL", /* 0x14 */ + "ANYOFPOSIXL", /* 0x15 */ + "ANYOFH", /* 0x16 */ + "ANYOFHb", /* 0x17 */ + "ANYOFHr", /* 0x18 */ + "ANYOFHs", /* 0x19 */ + "ANYOFR", /* 0x1a */ + "ANYOFRb", /* 0x1b */ + "ANYOFM", /* 0x1c */ + "NANYOFM", /* 0x1d */ + "POSIXD", /* 0x1e */ + "POSIXL", /* 0x1f */ + "POSIXU", /* 0x20 */ + "POSIXA", /* 0x21 */ + "NPOSIXD", /* 0x22 */ + "NPOSIXL", /* 0x23 */ + "NPOSIXU", /* 0x24 */ + "NPOSIXA", /* 0x25 */ + "CLUMP", /* 0x26 */ + "BRANCH", /* 0x27 */ + "EXACT", /* 0x28 */ + "LEXACT", /* 0x29 */ + "EXACTL", /* 0x2a */ + "EXACTF", /* 0x2b */ + "EXACTFL", /* 0x2c */ + "EXACTFU", /* 0x2d */ + "EXACTFAA", /* 0x2e */ + "EXACTFAA_NO_TRIE", /* 0x2f */ + "EXACTFUP", /* 0x30 */ + "EXACTFLU8", /* 0x31 */ + "EXACT_REQ8", /* 0x32 */ + "LEXACT_REQ8", /* 0x33 */ + "EXACTFU_REQ8", /* 0x34 */ + "EXACTFU_S_EDGE", /* 0x35 */ + "LNBREAK", /* 0x36 */ + "TRIE", /* 0x37 */ + "TRIEC", /* 0x38 */ + "AHOCORASICK", /* 0x39 */ + "AHOCORASICKC", /* 0x3a */ + "NOTHING", /* 0x3b */ + "TAIL", /* 0x3c */ + "STAR", /* 0x3d */ + "PLUS", /* 0x3e */ + "CURLY", /* 0x3f */ + "CURLYN", /* 0x40 */ + "CURLYM", /* 0x41 */ + "CURLYX", /* 0x42 */ + "WHILEM", /* 0x43 */ + "OPEN", /* 0x44 */ + "CLOSE", /* 0x45 */ + "SROPEN", /* 0x46 */ + "SRCLOSE", /* 0x47 */ + "REF", /* 0x48 */ + "REFF", /* 0x49 */ + "REFFL", /* 0x4a */ + "REFFU", /* 0x4b */ + "REFFA", /* 0x4c */ + "REFN", /* 0x4d */ + "REFFN", /* 0x4e */ + "REFFLN", /* 0x4f */ + "REFFUN", /* 0x50 */ + "REFFAN", /* 0x51 */ + "LONGJMP", /* 0x52 */ + "BRANCHJ", /* 0x53 */ + "IFMATCH", /* 0x54 */ + "UNLESSM", /* 0x55 */ + "SUSPEND", /* 0x56 */ + "IFTHEN", /* 0x57 */ + "GROUPP", /* 0x58 */ + "EVAL", /* 0x59 */ + "MINMOD", /* 0x5a */ + "LOGICAL", /* 0x5b */ + "RENUM", /* 0x5c */ "GOSUB", /* 0x5d */ - "GOSTART", /* 0x5e */ - "NGROUPP", /* 0x5f */ - "INSUBP", /* 0x60 */ - "DEFINEP", /* 0x61 */ - "ENDLIKE", /* 0x62 */ - "OPFAIL", /* 0x63 */ - "ACCEPT", /* 0x64 */ - "VERB", /* 0x65 */ - "PRUNE", /* 0x66 */ - "MARKPOINT", /* 0x67 */ - "SKIP", /* 0x68 */ - "COMMIT", /* 0x69 */ - "CUTGROUP", /* 0x6a */ - "KEEPS", /* 0x6b */ - "LNBREAK", /* 0x6c */ - "VERTWS", /* 0x6d */ - "NVERTWS", /* 0x6e */ - "HORIZWS", /* 0x6f */ - "NHORIZWS", /* 0x70 */ - "OPTIMIZED", /* 0x71 */ - "PSEUDO", /* 0x72 */ + "GROUPPN", /* 0x5e */ + "INSUBP", /* 0x5f */ + "DEFINEP", /* 0x60 */ + "ENDLIKE", /* 0x61 */ + "OPFAIL", /* 0x62 */ + "ACCEPT", /* 0x63 */ + "VERB", /* 0x64 */ + "PRUNE", /* 0x65 */ + "MARKPOINT", /* 0x66 */ + "SKIP", /* 0x67 */ + "COMMIT", /* 0x68 */ + "CUTGROUP", /* 0x69 */ + "KEEPS", /* 0x6a */ + "OPTIMIZED", /* 0x6b */ + "PSEUDO", /* 0x6c */ + "REGEX_SET", /* 0x6d */ /* ------------ States ------------- */ "TRIE_next", /* REGNODE_MAX +0x01 */ "TRIE_next_fail", /* REGNODE_MAX +0x02 */ - "EVAL_AB", /* REGNODE_MAX +0x03 */ - "EVAL_AB_fail", /* REGNODE_MAX +0x04 */ - "CURLYX_end", /* REGNODE_MAX +0x05 */ - "CURLYX_end_fail", /* REGNODE_MAX +0x06 */ - "WHILEM_A_pre", /* REGNODE_MAX +0x07 */ - "WHILEM_A_pre_fail", /* REGNODE_MAX +0x08 */ - "WHILEM_A_min", /* REGNODE_MAX +0x09 */ - "WHILEM_A_min_fail", /* REGNODE_MAX +0x0a */ - "WHILEM_A_max", /* REGNODE_MAX +0x0b */ - "WHILEM_A_max_fail", /* REGNODE_MAX +0x0c */ - "WHILEM_B_min", /* REGNODE_MAX +0x0d */ - "WHILEM_B_min_fail", /* REGNODE_MAX +0x0e */ - "WHILEM_B_max", /* REGNODE_MAX +0x0f */ - "WHILEM_B_max_fail", /* REGNODE_MAX +0x10 */ - "BRANCH_next", /* REGNODE_MAX +0x11 */ - "BRANCH_next_fail", /* REGNODE_MAX +0x12 */ - "CURLYM_A", /* REGNODE_MAX +0x13 */ - "CURLYM_A_fail", /* REGNODE_MAX +0x14 */ - "CURLYM_B", /* REGNODE_MAX +0x15 */ - "CURLYM_B_fail", /* REGNODE_MAX +0x16 */ - "IFMATCH_A", /* REGNODE_MAX +0x17 */ - "IFMATCH_A_fail", /* REGNODE_MAX +0x18 */ - "CURLY_B_min_known", /* REGNODE_MAX +0x19 */ - "CURLY_B_min_known_fail", /* REGNODE_MAX +0x1a */ + "EVAL_B", /* REGNODE_MAX +0x03 */ + "EVAL_B_fail", /* REGNODE_MAX +0x04 */ + "EVAL_postponed_AB", /* REGNODE_MAX +0x05 */ + "EVAL_postponed_AB_fail", /* REGNODE_MAX +0x06 */ + "CURLYX_end", /* REGNODE_MAX +0x07 */ + "CURLYX_end_fail", /* REGNODE_MAX +0x08 */ + "WHILEM_A_pre", /* REGNODE_MAX +0x09 */ + "WHILEM_A_pre_fail", /* REGNODE_MAX +0x0a */ + "WHILEM_A_min", /* REGNODE_MAX +0x0b */ + "WHILEM_A_min_fail", /* REGNODE_MAX +0x0c */ + "WHILEM_A_max", /* REGNODE_MAX +0x0d */ + "WHILEM_A_max_fail", /* REGNODE_MAX +0x0e */ + "WHILEM_B_min", /* REGNODE_MAX +0x0f */ + "WHILEM_B_min_fail", /* REGNODE_MAX +0x10 */ + "WHILEM_B_max", /* REGNODE_MAX +0x11 */ + "WHILEM_B_max_fail", /* REGNODE_MAX +0x12 */ + "BRANCH_next", /* REGNODE_MAX +0x13 */ + "BRANCH_next_fail", /* REGNODE_MAX +0x14 */ + "CURLYM_A", /* REGNODE_MAX +0x15 */ + "CURLYM_A_fail", /* REGNODE_MAX +0x16 */ + "CURLYM_B", /* REGNODE_MAX +0x17 */ + "CURLYM_B_fail", /* REGNODE_MAX +0x18 */ + "IFMATCH_A", /* REGNODE_MAX +0x19 */ + "IFMATCH_A_fail", /* REGNODE_MAX +0x1a */ "CURLY_B_min", /* REGNODE_MAX +0x1b */ "CURLY_B_min_fail", /* REGNODE_MAX +0x1c */ "CURLY_B_max", /* REGNODE_MAX +0x1d */ @@ -745,32 +1644,32 @@ EXTCONST char * const PL_reg_name[] = { EXTCONST char * PL_reg_extflags_name[]; #else EXTCONST char * const PL_reg_extflags_name[] = { - /* Bits in extflags defined: 11111111111111111111111011111111 */ + /* Bits in extflags defined: 11111111111111110000111111111111 */ "MULTILINE", /* 0x00000001 */ "SINGLELINE", /* 0x00000002 */ "FOLD", /* 0x00000004 */ "EXTENDED", /* 0x00000008 */ - "KEEPCOPY", /* 0x00000010 */ - "CHARSET", /* 0x000000e0 */ - "CHARSET", /* 0x000000e0 */ - "CHARSET", /* 0x000000e0 */ - "UNUSED_BIT_8", /* 0x00000100 */ - "ANCH_BOL", /* 0x00000200 */ - "ANCH_MBOL", /* 0x00000400 */ - "ANCH_SBOL", /* 0x00000800 */ - "ANCH_GPOS", /* 0x00001000 */ - "GPOS_SEEN", /* 0x00002000 */ - "GPOS_FLOAT", /* 0x00004000 */ - "LOOKBEHIND_SEEN", /* 0x00008000 */ - "EVAL_SEEN", /* 0x00010000 */ - "CANY_SEEN", /* 0x00020000 */ - "NOSCAN", /* 0x00040000 */ + "EXTENDED_MORE", /* 0x00000010 */ + "NOCAPTURE", /* 0x00000020 */ + "KEEPCOPY", /* 0x00000040 */ + "CHARSET0", /* 0x00000080 : "CHARSET" - 0x00000380 */ + "CHARSET1", /* 0x00000100 : "CHARSET" - 0x00000380 */ + "CHARSET2", /* 0x00000200 : "CHARSET" - 0x00000380 */ + "STRICT", /* 0x00000400 */ + "SPLIT", /* 0x00000800 */ + "UNUSED_BIT_12", /* 0x00001000 */ + "UNUSED_BIT_13", /* 0x00002000 */ + "UNUSED_BIT_14", /* 0x00004000 */ + "UNUSED_BIT_15", /* 0x00008000 */ + "NO_INPLACE_SUBST", /* 0x00010000 */ + "EVAL_SEEN", /* 0x00020000 */ + "UNBOUNDED_QUANTIFIER_SEEN",/* 0x00040000 */ "CHECK_ALL", /* 0x00080000 */ "MATCH_UTF8", /* 0x00100000 */ "USE_INTUIT_NOML", /* 0x00200000 */ "USE_INTUIT_ML", /* 0x00400000 */ "INTUIT_TAIL", /* 0x00800000 */ - "SPLIT", /* 0x01000000 */ + "IS_ANCHORED", /* 0x01000000 */ "COPY_DONE", /* 0x02000000 */ "TAINTED_SEEN", /* 0x04000000 */ "TAINTED", /* 0x08000000 */ @@ -781,6 +1680,36 @@ EXTCONST char * const PL_reg_extflags_name[] = { }; #endif /* DOINIT */ +#ifdef DEBUGGING +# define REG_EXTFLAGS_NAME_SIZE 32 +#endif + +/* PL_reg_intflags_name[] - Opcode/state names in string form, for debugging */ + +#ifndef DOINIT +EXTCONST char * PL_reg_intflags_name[]; +#else +EXTCONST char * const PL_reg_intflags_name[] = { + "SKIP", /* 0x00000001 - PREGf_SKIP */ + "IMPLICIT", /* 0x00000002 - PREGf_IMPLICIT - Converted .* to ^.* */ + "NAUGHTY", /* 0x00000004 - PREGf_NAUGHTY - how exponential is this pattern? */ + "VERBARG_SEEN", /* 0x00000008 - PREGf_VERBARG_SEEN */ + "CUTGROUP_SEEN", /* 0x00000010 - PREGf_CUTGROUP_SEEN */ + "USE_RE_EVAL", /* 0x00000020 - PREGf_USE_RE_EVAL - compiled with "use re 'eval'" */ + "NOSCAN", /* 0x00000040 - PREGf_NOSCAN */ + "GPOS_SEEN", /* 0x00000100 - PREGf_GPOS_SEEN */ + "GPOS_FLOAT", /* 0x00000200 - PREGf_GPOS_FLOAT */ + "ANCH_MBOL", /* 0x00000400 - PREGf_ANCH_MBOL */ + "ANCH_SBOL", /* 0x00000800 - PREGf_ANCH_SBOL */ + "ANCH_GPOS", /* 0x00001000 - PREGf_ANCH_GPOS */ + "RECURSE_SEEN", /* 0x00002000 - PREGf_RECURSE_SEEN */ +}; +#endif /* DOINIT */ + +#ifdef DEBUGGING +# define REG_INTFLAGS_NAME_SIZE 13 +#endif + /* The following have no fixed length. U8 so we can do strchr() on it. */ #define REGNODE_VARIES(node) (PL_varies_bitmask[(node) >> 3] & (1 << ((node) & 7))) @@ -788,9 +1717,9 @@ EXTCONST char * const PL_reg_extflags_name[] = { EXTCONST U8 PL_varies[] __attribute__deprecated__; #else EXTCONST U8 PL_varies[] __attribute__deprecated__ = { - ANYOFV, CLUMP, BRANCH, BACK, STAR, PLUS, CURLY, CURLYN, CURLYM, CURLYX, - WHILEM, REF, REFF, REFFL, REFFU, REFFA, NREF, NREFF, NREFFL, NREFFU, - NREFFA, SUSPEND, IFTHEN, BRANCHJ, + CLUMP, BRANCH, STAR, PLUS, CURLY, CURLYN, CURLYM, CURLYX, WHILEM, REF, + REFF, REFFL, REFFU, REFFA, REFN, REFFN, REFFLN, REFFUN, REFFAN, + BRANCHJ, SUSPEND, IFTHEN, 0 }; #endif /* DOINIT */ @@ -799,7 +1728,7 @@ EXTCONST U8 PL_varies[] __attribute__deprecated__ = { EXTCONST U8 PL_varies_bitmask[]; #else EXTCONST U8 PL_varies_bitmask[] = { - 0x00, 0x00, 0x40, 0x00, 0x00, 0x80, 0x03, 0xF8, 0xF3, 0x3F, 0x13, 0x00, 0x00, 0x00, 0x00 + 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0xE0, 0x0F, 0xFF, 0xCB, 0x00, 0x00, 0x00 }; #endif /* DOINIT */ @@ -811,10 +1740,9 @@ EXTCONST U8 PL_varies_bitmask[] = { EXTCONST U8 PL_simple[] __attribute__deprecated__; #else EXTCONST U8 PL_simple[] __attribute__deprecated__ = { - REG_ANY, SANY, CANY, ANYOF, ALNUM, ALNUML, ALNUMU, ALNUMA, NALNUM, - NALNUML, NALNUMU, NALNUMA, SPACE, SPACEL, SPACEU, SPACEA, NSPACE, - NSPACEL, NSPACEU, NSPACEA, DIGIT, DIGITL, DIGITA, NDIGIT, NDIGITL, - NDIGITA, VERTWS, NVERTWS, HORIZWS, NHORIZWS, + REG_ANY, SANY, ANYOF, ANYOFD, ANYOFL, ANYOFPOSIXL, ANYOFH, ANYOFHb, + ANYOFHr, ANYOFHs, ANYOFR, ANYOFRb, ANYOFM, NANYOFM, POSIXD, POSIXL, + POSIXU, POSIXA, NPOSIXD, NPOSIXL, NPOSIXU, NPOSIXA, REGEX_SET, 0 }; #endif /* DOINIT */ @@ -823,8 +1751,24 @@ EXTCONST U8 PL_simple[] __attribute__deprecated__ = { EXTCONST U8 PL_simple_bitmask[]; #else EXTCONST U8 PL_simple_bitmask[] = { - 0x00, 0x00, 0xBC, 0xFF, 0xFF, 0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01 + 0x00, 0x00, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20 }; #endif /* DOINIT */ +/* Is 'op', known to be of type EXACT, folding? */ +#define isEXACTFish(op) (__ASSERT_(PL_regkind[op] == EXACT) (PL_EXACTFish_bitmask & (1U << (op - EXACT)))) + +/* Do only UTF-8 target strings match 'op', known to be of type EXACT? */ +#define isEXACT_REQ8(op) (__ASSERT_(PL_regkind[op] == EXACT) (PL_EXACT_REQ8_bitmask & (1U << (op - EXACT)))) + +#ifndef DOINIT +EXTCONST U32 PL_EXACTFish_bitmask; +EXTCONST U32 PL_EXACT_REQ8_bitmask; +#else +EXTCONST U32 PL_EXACTFish_bitmask = 0x33F8; +EXTCONST U32 PL_EXACT_REQ8_bitmask = 0x1E00; +#endif /* DOINIT */ + +#endif /* defined(PERL_CORE) || defined(PERL_EXT_RE_BUILD) */ + /* ex: set ro: */