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