X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/8d919b0a35f2b57a6bed2f8355b25b19ac5ad0c5..2305393164b3d13f11b4ce5297bb8a40499936b7:/regcomp.h diff --git a/regcomp.h b/regcomp.h index e9a64fe..0b69f6e 100644 --- a/regcomp.h +++ b/regcomp.h @@ -26,13 +26,6 @@ #define RE_TRACK_PATTERN_OFFSETS #endif -/* Unless the next line is uncommented it is illegal to combine lazy - matching with possessive matching. Frankly it doesn't make much sense - to allow it as X*?+ matches nothing, X+?+ matches a single char only, - and X{min,max}?+ matches min times only. - */ -/* #define REG_ALLOW_MINMOD_SUSPEND */ - /* * The "internal use only" fields in regexp.h are present to pass info from * compile to execute that permits the execute phase to run lots faster on @@ -91,9 +84,7 @@ * but allows patterns to get big without disasters. * * [The "next" pointer is always aligned on an even - * boundary, and reads the offset directly as a short. Also, there is no - * special test to reverse the sign of BACK pointers since the offset is - * stored negative.] + * boundary, and reads the offset directly as a short.] */ /* This is the stuff that used to live in regexp.h that was truly @@ -132,13 +123,27 @@ * * See regexp.h for flags used externally to the regexp engine */ +#define RXp_INTFLAGS(rx) ((rx)->intflags) +#define RX_INTFLAGS(prog) RXp_INTFLAGS(ReANY(prog)) + #define PREGf_SKIP 0x00000001 #define PREGf_IMPLICIT 0x00000002 /* Converted .* to ^.* */ #define PREGf_NAUGHTY 0x00000004 /* how exponential is this pattern? */ #define PREGf_VERBARG_SEEN 0x00000008 #define PREGf_CUTGROUP_SEEN 0x00000010 #define PREGf_USE_RE_EVAL 0x00000020 /* compiled with "use re 'eval'" */ +/* these used to be extflags, but are now intflags */ +#define PREGf_NOSCAN 0x00000040 + /* spare */ +#define PREGf_GPOS_SEEN 0x00000100 +#define PREGf_GPOS_FLOAT 0x00000200 + +#define PREGf_ANCH_MBOL 0x00000400 +#define PREGf_ANCH_SBOL 0x00000800 +#define PREGf_ANCH_GPOS 0x00001000 +#define PREGf_ANCH \ + ( PREGf_ANCH_SBOL | PREGf_ANCH_GPOS | PREGf_ANCH_MBOL ) /* this is where the old regcomp.h started */ @@ -176,29 +181,88 @@ struct regnode_2 { U16 arg2; }; - -#define ANYOF_BITMAP_SIZE 32 /* 256 b/(8 b/B) */ -#define ANYOF_CLASSBITMAP_SIZE 4 /* up to 32 (8*4) named classes */ +/* This give the number of code points that can be in the bitmap of an ANYOF + * node. The shift number must currently be one of: 8..12. It can't be less + * than 8 (256) because some code relies on it being at least that. Above 12 + * (4096), and you start running into warnings that some data structure widths + * have been exceeded, though the test suite as of this writing still passes + * for up through 16, which is as high as anyone would ever want to go, + * encompassing all of the Unicode BMP, and thus including all the economically + * important world scripts. At 12 most of them are: including Arabic, + * Cyrillic, Greek, Hebrew, Indian subcontinent, Latin, and Thai; but not Han, + * Japanese, nor Korean. (The regarglen structure in regnodes.h is a U8, and + * the trie types TRIEC and AHOCORASICKC are larger than U8 for shift values + * below above 12.) Be sure to benchmark before changing, as larger sizes do + * significantly slow down the test suite */ +#define NUM_ANYOF_CODE_POINTS (1 << 8) + +#define ANYOF_BITMAP_SIZE (NUM_ANYOF_CODE_POINTS / 8) /* 8 bits/Byte */ + +/* Note that these form structs which are supersets of the next smaller one, by + * appending fields. Alignment problems can occur if one of those optional + * fields requires stricter alignment than the base struct. And formal + * parameters that can really be two or more of the structs should be + * declared as the smallest one it could be. See commit message for + * 7dcac5f6a5195002b55c935ee1d67f67e1df280b. Regnode allocation is done + * without regard to alignment, and changing it to would also require changing + * the code that inserts and deletes regnodes. The basic single-argument + * regnode has a U32, which is what reganode() allocates as a unit. Therefore + * no field can require stricter alignment than U32. */ /* also used by trie */ struct regnode_charclass { U8 flags; U8 type; U16 next_off; - U32 arg1; /* used as ptr in S_regclass */ + U32 arg1; /* set by set_ANYOF_arg() */ char bitmap[ANYOF_BITMAP_SIZE]; /* only compile-time */ }; /* has runtime (locale) \d, \w, ..., [:posix:] classes */ struct regnode_charclass_class { - U8 flags; /* ANYOF_CLASS bit must go here */ + U8 flags; /* ANYOF_MATCHES_POSIXL bit must go here */ + U8 type; + U16 next_off; + U32 arg1; + char bitmap[ANYOF_BITMAP_SIZE]; /* both compile-time ... */ + U32 classflags; /* and run-time */ +}; + +/* A synthetic start class (SSC); is a regnode_charclass_posixl_fold, plus an + * extra SV*, used only during its construction and which is not used by + * regexec.c. Note that the 'next_off' field is unused, as the SSC stands + * alone, so there is never a next node. Also, there is no alignment issue, + * because these are declared or allocated as a complete unit so the compiler + * takes care of alignment. This is unlike the other regnodes which are + * allocated in terms of multiples of a single-argument regnode. SSC nodes can + * have a pointer field because there is no alignment issue, and because it is + * set to NULL after construction, before any cloning of the pattern */ +struct regnode_ssc { + U8 flags; /* ANYOF_MATCHES_POSIXL bit must go here */ U8 type; U16 next_off; - U32 arg1; /* used as ptr in S_regclass */ - char bitmap[ANYOF_BITMAP_SIZE]; /* both compile-time */ - char classflags[ANYOF_CLASSBITMAP_SIZE]; /* and run-time */ + U32 arg1; + char bitmap[ANYOF_BITMAP_SIZE]; /* both compile-time ... */ + U32 classflags; /* ... and run-time */ + + /* Auxiliary, only used during construction; NULL afterwards: list of code + * points matched */ + SV* invlist; }; +/* We take advantage of 'next_off' not otherwise being used in the SSC by + * actually using it: by setting it to 1. This allows us to test and + * distinguish between an SSC and other ANYOF node types, as 'next_off' cannot + * otherwise be 1, because it is the offset to the next regnode expressed in + * units of regnodes. Since an ANYOF node contains extra fields, it adds up + * to 12 regnode units on 32-bit systems, (hence the minimum this can be (if + * not 0) is 11 there. Even if things get tightly packed on a 64-bit system, + * it still would be more than 1. */ +#define set_ANYOF_SYNTHETIC(n) STMT_START{ OP(n) = ANYOF; \ + NEXT_OFF(n) = 1; \ + } STMT_END +#define is_ANYOF_SYNTHETIC(n) (PL_regkind[OP(n)] == ANYOF && NEXT_OFF(n) == 1) + /* XXX fix this description. Impose a limit of REG_INFTY on various pattern matching operations to limit stack growth and to avoid "infinite" recursions. @@ -243,7 +307,16 @@ struct regnode_charclass_class { #define NEXT_OFF(p) ((p)->next_off) #define NODE_ALIGN(node) -#define NODE_ALIGN_FILL(node) ((node)->flags = 0xde) /* deadbeef */ +/* the following define was set to 0xde in 075abff3 + * as part of some linting logic. I have set it to 0 + * as otherwise in every place where we /might/ set flags + * we have to set it 0 explicitly, which duplicates + * assignments and IMO adds an unacceptable level of + * surprise to working in the regex engine. If this + * is changed from 0 then at the very least make sure + * that SBOL for /^/ sets the flags to 0 explicitly. + * -- Yves */ +#define NODE_ALIGN_FILL(node) ((node)->flags = 0) #define SIZE_ALIGN NODE_ALIGN @@ -286,118 +359,148 @@ struct regnode_charclass_class { (ptr)->type = op; (ptr)->next_off = 0; (ptr)++; } STMT_END #define FILL_ADVANCE_NODE_ARG(ptr, op, arg) STMT_START { \ ARG_SET(ptr, arg); FILL_ADVANCE_NODE(ptr, op); (ptr) += 1; } STMT_END +#define FILL_ADVANCE_NODE_2L_ARG(ptr, op, arg1, arg2) \ + STMT_START { \ + ARG_SET(ptr, arg1); \ + ARG2L_SET(ptr, arg2); \ + FILL_ADVANCE_NODE(ptr, op); \ + (ptr) += 2; \ + } STMT_END #define REG_MAGIC 0234 -#define SIZE_ONLY (RExC_emit == &PL_regdummy) +#define SIZE_ONLY (RExC_emit == (regnode *) & RExC_emit_dummy) +#define PASS1 SIZE_ONLY +#define PASS2 (! SIZE_ONLY) -/* If the bitmap doesn't fully represent what this ANYOF node can match, the +/* If the bitmap fully represents what this ANYOF node can match, the * ARG is set to this special value (since 0, 1, ... are legal, but will never * reach this high). */ -#define ANYOF_NONBITMAP_EMPTY ((U32) -1) - -/* The information used to be stored as as combination of the ANYOF_UTF8 and - * ANYOF_NONBITMAP_NON_UTF8 bits in the flags field, but was moved out of there - * to free up a bit for other uses. This tries to hide the change from - * existing code as much as possible. Now, the data structure that goes in ARG - * is not allocated unless it is needed, and that is what is used to determine - * if there is something outside the bitmap. The code now assumes that if - * that structure exists, that any UTF-8 encoded string should be tried against - * it, but a non-UTF8-encoded string will be tried only if the - * ANYOF_NONBITMAP_NON_UTF8 bit is also set. */ -#define ANYOF_NONBITMAP(node) (ARG(node) != ANYOF_NONBITMAP_EMPTY) - -/* Flags for node->flags of ANYOF. These are in short supply, so some games - * are done to share them, as described below. Already, the ANYOF_LOCALE and - * ANYOF_CLASS bits are shared, making a space penalty for all locale nodes. - * An option would be to push them into new nodes. E.g. there could be an - * ANYOF_LOCALE node that would be in place of the flag of the same name. But - * there are better options. The UNICODE_ALL bit could be freed up by - * resorting to creating a swash containing everything above 255. This - * introduces a performance penalty. Better would be to split it off into a - * separate node, which actually would improve performance by allowing adding a - * case statement to regexec.c use the bit map for code points under 256, and - * 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 scc, freeing up that bit */ - -#define ANYOF_LOCALE 0x01 /* /l modifier */ +#define ANYOF_ONLY_HAS_BITMAP ((U32) -1) + +/* Below are the flags for node->flags of ANYOF. These are in short supply, + * with none currently available. The ABOVE_BITMAP_ALL bit could be freed up + * by resorting to creating a swash containing everything above 255. This + * seems likely to introduce a performance penalty (but actual numbers haven't + * been done), so its probably better do some of the other possibilities below + * in preference to this. + * + * If just one bit is required, it seems to me (khw) that the best option would + * be to turn the ANYOF_LOC_REQ_UTF8 bit into a separate node type: a + * specialization of the ANYOFL type, freeing up the currently occupied bit. + * When turning a bit into a node type, one has to take into consideration that + * a SSC may use that bit -- not just a regular ANYOF[DL]?. In the case of + * ANYOF_LOC_REQ_UTF8, the only likely problem is accurately settting the SSC + * node-type to the new one, which would likely involve S_ssc_or and S_ssc_and, + * and not how the SSC currently gets set to ANYOFL. This bit is a natural + * candidate for being a separate node type because it is a specialization of + * the current ANYOFL, and because no other ANYOFL-only bits are set when it + * is; also most of its uses are actually outside the reginclass() function, so + * this could be done with no performance penalty. The other potential bits + * seem to me to have a potential issue with a combinatorial explosion of node + * types, because of not having that mutual exclusivity, where you may end up + * having to have a node type for bitX being set, one for bitY, and one for + * both bitXY. + * + * If you don't want to do this, or two bits are required, one could instead + * rename the ANYOF_POSIXL bit to be ANYOFL_LARGE, to mean that the ANYOF node + * has an extra 32 bits beyond what a regular one does. That's what it + * effectively means now, with the extra space all for the POSIX class bits. + * But those classes actually only occupy 30 bits, so the ANYOF_LOC_REQ_BIT (if + * an extra node type for it hasn't been created) and/or the ANYOF_LOC_FOLD + * bits could be moved there. The downside of this is that ANYOFL nodes with + * whichever of the bits get moved would have to have the extra space always + * allocated. + * + * If three bits are required, one could additionally make a node type for + * ANYOFL_LARGE, removing that as a bit, and move both the above bits to that + * extra word. There isn't an SSC problem as all SSCs are this large anyway, + * and the SSC could be set to this node type. REGINCLASS would have to be + * modified so that if the node type were this, it would call reginclass(). + * as the flag bit that does this now would be gone. + * + * Several flags are not used in synthetic start class (SSC) nodes, so could be + * shared should new flags be needed for SSCs, like SSC_MATCHES_EMPTY_STRING + * now. */ -/* The fold is calculated and stored in the bitmap where possible at compile - * time. However under locale, the actual folding varies depending on - * what the locale is at the time of execution, so it has to be deferred until - * then */ -#define ANYOF_LOC_FOLD 0x02 +/* If this is set, the result of the match should be complemented. regexec.c + * is expecting this to be in the low bit. Never in an SSC */ +#define ANYOF_INVERT 0x01 -#define ANYOF_INVERT 0x04 +/* For the SSC node only, which cannot be inverted, so is shared with that bit. + * This is used only during regex compilation. */ +#define SSC_MATCHES_EMPTY_STRING ANYOF_INVERT -/* Set if this is a struct regnode_charclass_class vs a regnode_charclass. This +/* Set if this is a regnode_charclass_posixl vs a regnode_charclass. This * is used for runtime \d, \w, [:posix:], ..., which are used only in locale * and the optimizer's synthetic start class. Non-locale \d, etc are resolved - * at compile-time. Now shared with ANYOF_LOCALE, forcing all locale nodes to - * be large */ -#define ANYOF_CLASS ANYOF_LOCALE -#define ANYOF_LARGE ANYOF_CLASS /* Same; name retained for back compat */ - -/* Should this character class warn if matched against a character above - * Unicode */ -#define ANYOF_WARN_SUPER 0x08 - -/* EOS, meaning that it can match an empty string too, is used for the - * 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 - -/* Matches every code point 0x100 and above*/ -#define ANYOF_UNICODE_ALL 0x40 - -/* Match all Latin1 characters that aren't ASCII when the target string is not - * in utf8. */ -#define ANYOF_NON_UTF8_LATIN1_ALL 0x80 - -#define ANYOF_FLAGS_ALL 0xff - -/* These are the flags that ANYOF_INVERT being set or not doesn't affect - * whether they are operative or not. e.g., the node still has LOCALE - * regardless of being inverted; whereas ANYOF_UNICODE_ALL means something - * different if inverted */ -#define INVERSION_UNAFFECTED_FLAGS (ANYOF_LOCALE \ - |ANYOF_LOC_FOLD \ - |ANYOF_CLASS \ - |ANYOF_EOS \ - |ANYOF_NONBITMAP_NON_UTF8) + * at compile-time. Only set under /l; can be in SSC */ +#define ANYOF_MATCHES_POSIXL 0x02 + +/* The fold is calculated and stored in the bitmap where possible at compile + * time. However under locale, the actual folding varies depending on + * what the locale is at the time of execution, so it has to be deferred until + * then. Only set under /l; never in an SSC */ +#define ANYOF_LOC_FOLD 0x04 + +/* If set, means to warn if runtime locale isn't a UTF-8 one. Only under /l. + * If set, none of INVERT, LOC_FOLD, POSIXL, HAS_NONBITMAP_NON_UTF8_MATCHES can + * be set. Can be in an SSC */ +#define ANYOF_LOC_REQ_UTF8 0x08 + +/* If set, the node matches every code point NUM_ANYOF_CODE_POINTS and above. + * Can be in an SSC */ +#define ANYOF_MATCHES_ALL_ABOVE_BITMAP 0x10 + +/* If set, the node can match something outside the bitmap that isn't in utf8; + * never set under /d nor in an SSC */ +#define ANYOF_HAS_NONBITMAP_NON_UTF8_MATCHES 0x20 + +/* Are there things outside the bitmap that will match only if the target + * string is encoded in UTF-8? (This is not set if ANYOF_ABOVE_BITMAP_ALL is + * set). Can be in SSC */ +#define ANYOF_HAS_UTF8_NONBITMAP_MATCHES 0x40 + +/* Shared bit: + * Under /d it means the ANYOFD node matches all non-ASCII Latin1 + * characters when the target string is not in utf8. + * When not under /d, it means the ANYOF node should raise a warning if + * matching against an above-Unicode code point. + * (These uses are mutually exclusive because the warning requires a \p{}, and + * \p{} implies /u which deselects /d). An SSC node only has this bit set if + * what is meant is the warning. The long macro name is to make sure that you + * are cautioned about its shared nature */ +#define ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER 0x80 + +#define ANYOF_FLAGS_ALL (0xff) + +#define ANYOF_LOCALE_FLAGS (ANYOF_LOC_FOLD | ANYOF_MATCHES_POSIXL) + +/* These are the flags that apply to both regular ANYOF nodes and synthetic + * start class nodes during construction of the SSC. During finalization of + * the SSC, other of the flags may get added to it */ +#define ANYOF_COMMON_FLAGS ( ANYOF_HAS_UTF8_NONBITMAP_MATCHES \ + |ANYOF_LOC_REQ_UTF8) /* Character classes for node->classflags of ANYOF */ /* Should be synchronized with a table in regprop() */ /* 2n should be the normal one, paired with its complement at 2n+1 */ -#define ANYOF_WORDCHAR ((_CC_WORDCHAR) * 2) /* \w, PL_utf8_alnum, utf8::IsWord, ALNUM */ -#define ANYOF_NWORDCHAR ((ANYOF_WORDCHAR) + 1) -#define ANYOF_SPACE ((_CC_SPACE) * 2) /* \s */ -#define ANYOF_NSPACE ((ANYOF_SPACE) + 1) -#define ANYOF_DIGIT ((_CC_DIGIT) * 2) /* \d */ -#define ANYOF_NDIGIT ((ANYOF_DIGIT) + 1) -#define ANYOF_ALNUMC ((_CC_ALNUMC) * 2) /* [[:alnum:]] isalnum(3), utf8::IsAlnum, ALNUMC */ -#define ANYOF_NALNUMC ((ANYOF_ALNUMC) + 1) #define ANYOF_ALPHA ((_CC_ALPHA) * 2) #define ANYOF_NALPHA ((ANYOF_ALPHA) + 1) +#define ANYOF_ALPHANUMERIC ((_CC_ALPHANUMERIC) * 2) /* [[:alnum:]] isalnum(3), utf8::IsAlnum */ +#define ANYOF_NALPHANUMERIC ((ANYOF_ALPHANUMERIC) + 1) #define ANYOF_ASCII ((_CC_ASCII) * 2) #define ANYOF_NASCII ((ANYOF_ASCII) + 1) +#define ANYOF_BLANK ((_CC_BLANK) * 2) /* GNU extension: space and tab: non-vertical space */ +#define ANYOF_NBLANK ((ANYOF_BLANK) + 1) +#define ANYOF_CASED ((_CC_CASED) * 2) /* Pseudo class for [:lower:] or + [:upper:] under /i */ +#define ANYOF_NCASED ((ANYOF_CASED) + 1) #define ANYOF_CNTRL ((_CC_CNTRL) * 2) #define ANYOF_NCNTRL ((ANYOF_CNTRL) + 1) +#define ANYOF_DIGIT ((_CC_DIGIT) * 2) /* \d */ +#define ANYOF_NDIGIT ((ANYOF_DIGIT) + 1) #define ANYOF_GRAPH ((_CC_GRAPH) * 2) #define ANYOF_NGRAPH ((ANYOF_GRAPH) + 1) #define ANYOF_LOWER ((_CC_LOWER) * 2) @@ -406,27 +509,42 @@ struct regnode_charclass_class { #define ANYOF_NPRINT ((ANYOF_PRINT) + 1) #define ANYOF_PUNCT ((_CC_PUNCT) * 2) #define ANYOF_NPUNCT ((ANYOF_PUNCT) + 1) +#define ANYOF_SPACE ((_CC_SPACE) * 2) /* \s */ +#define ANYOF_NSPACE ((ANYOF_SPACE) + 1) #define ANYOF_UPPER ((_CC_UPPER) * 2) #define ANYOF_NUPPER ((ANYOF_UPPER) + 1) +#define ANYOF_WORDCHAR ((_CC_WORDCHAR) * 2) /* \w, PL_utf8_alnum, utf8::IsWord, ALNUM */ +#define ANYOF_NWORDCHAR ((ANYOF_WORDCHAR) + 1) #define ANYOF_XDIGIT ((_CC_XDIGIT) * 2) #define ANYOF_NXDIGIT ((ANYOF_XDIGIT) + 1) -#define ANYOF_PSXSPC ((_CC_PSXSPC) * 2) /* POSIX space: \s plus the vertical tab */ -#define ANYOF_NPSXSPC ((ANYOF_PSXSPC) + 1) -#define ANYOF_BLANK ((_CC_BLANK) * 2) /* GNU extension: space and tab: non-vertical space */ -#define ANYOF_NBLANK ((ANYOF_BLANK) + 1) -#define ANYOF_MAX 32 -#if (ANYOF_MAX <= _HIGHEST_REGCOMP_DOT_H_SYNC * 2 + 1) +/* pseudo classes below this, not stored in the class bitmap, but used as flags + during compilation of char classes */ + +#define ANYOF_VERTWS ((_CC_VERTSPACE) * 2) +#define ANYOF_NVERTWS ((ANYOF_VERTWS)+1) + +/* It is best if this is the last one, as all above it are stored as bits in a + * bitmap, and it isn't part of that bitmap */ +#if _CC_VERTSPACE != _HIGHEST_REGCOMP_DOT_H_SYNC +# error Problem with handy.h _HIGHEST_REGCOMP_DOT_H_SYNC #define +#endif + +#define ANYOF_POSIXL_MAX (ANYOF_VERTWS) /* So upper loop limit is written: + * '< ANYOF_MAX' + * Hence doesn't include VERTWS, as that + * is a pseudo class */ +#define ANYOF_MAX ANYOF_POSIXL_MAX + +#if (ANYOF_POSIXL_MAX > 32) /* Must fit in 32-bit word */ # error Problem with handy.h _CC_foo #defines #endif -/* pseudo classes, not stored in the class bitmap, but used as flags - during compilation of char classes */ +#define ANYOF_HORIZWS ((ANYOF_POSIXL_MAX)+2) /* = (ANYOF_NVERTWS + 1) */ +#define ANYOF_NHORIZWS ((ANYOF_POSIXL_MAX)+3) -#define ANYOF_VERTWS (ANYOF_MAX+1) -#define ANYOF_NVERTWS (ANYOF_MAX+2) -#define ANYOF_HORIZWS (ANYOF_MAX+3) -#define ANYOF_NHORIZWS (ANYOF_MAX+4) +#define ANYOF_UNIPROP ((ANYOF_POSIXL_MAX)+4) /* Used to indicate a Unicode + property: \p{} or \P{} */ /* Backward source code compatibility. */ @@ -439,49 +557,63 @@ struct regnode_charclass_class { /* Utility macros for the bitmap and classes of ANYOF */ -#define ANYOF_SIZE (sizeof(struct regnode_charclass)) -#define ANYOF_CLASS_SIZE (sizeof(struct regnode_charclass_class)) - #define ANYOF_FLAGS(p) ((p)->flags) -#define ANYOF_BIT(c) (1 << ((c) & 7)) +#define ANYOF_BIT(c) (1U << ((c) & 7)) -#define ANYOF_CLASS_BYTE(p, c) (((struct regnode_charclass_class*)(p))->classflags[((c) >> 3) & 3]) -#define ANYOF_CLASS_SET(p, c) (ANYOF_CLASS_BYTE(p, c) |= ANYOF_BIT(c)) -#define ANYOF_CLASS_CLEAR(p, c) (ANYOF_CLASS_BYTE(p, c) &= ~ANYOF_BIT(c)) -#define ANYOF_CLASS_TEST(p, c) (ANYOF_CLASS_BYTE(p, c) & ANYOF_BIT(c)) +#define ANYOF_POSIXL_SET(p, c) (((regnode_charclass_posixl*) (p))->classflags |= (1U << (c))) +#define ANYOF_CLASS_SET(p, c) ANYOF_POSIXL_SET((p), (c)) -#define ANYOF_CLASS_ZERO(ret) Zero(((struct regnode_charclass_class*)(ret))->classflags, ANYOF_CLASSBITMAP_SIZE, char) -#define ANYOF_CLASS_SETALL(ret) \ - memset (((struct regnode_charclass_class*)(ret))->classflags, 255, ANYOF_CLASSBITMAP_SIZE) -#define ANYOF_BITMAP_ZERO(ret) Zero(((struct regnode_charclass*)(ret))->bitmap, ANYOF_BITMAP_SIZE, char) +#define ANYOF_POSIXL_CLEAR(p, c) (((regnode_charclass_posixl*) (p))->classflags &= ~ (1U <<(c))) +#define ANYOF_CLASS_CLEAR(p, c) ANYOF_POSIXL_CLEAR((p), (c)) + +#define ANYOF_POSIXL_TEST(p, c) (((regnode_charclass_posixl*) (p))->classflags & (1U << (c))) +#define ANYOF_CLASS_TEST(p, c) ANYOF_POSIXL_TEST((p), (c)) + +#define ANYOF_POSIXL_ZERO(ret) STMT_START { ((regnode_charclass_posixl*) (ret))->classflags = 0; } STMT_END +#define ANYOF_CLASS_ZERO(ret) ANYOF_POSIXL_ZERO(ret) + +/* Shifts a bit to get, eg. 0x4000_0000, then subtracts 1 to get 0x3FFF_FFFF */ +#define ANYOF_POSIXL_SETALL(ret) STMT_START { ((regnode_charclass_posixl*) (ret))->classflags = ((1U << ((ANYOF_POSIXL_MAX) - 1))) - 1; } STMT_END +#define ANYOF_CLASS_SETALL(ret) ANYOF_POSIXL_SETALL(ret) + +#define ANYOF_POSIXL_TEST_ANY_SET(p) \ + ((ANYOF_FLAGS(p) & ANYOF_MATCHES_POSIXL) \ + && (((regnode_charclass_posixl*)(p))->classflags)) +#define ANYOF_CLASS_TEST_ANY_SET(p) ANYOF_POSIXL_TEST_ANY_SET(p) + +/* Since an SSC always has this field, we don't have to test for that; nor do + * we want to because the bit isn't set for SSC during its construction */ +#define ANYOF_POSIXL_SSC_TEST_ANY_SET(p) \ + cBOOL(((regnode_ssc*)(p))->classflags) +#define ANYOF_POSIXL_SSC_TEST_ALL_SET(p) /* Are all bits set? */ \ + (((regnode_ssc*) (p))->classflags \ + == ((1U << ((ANYOF_POSIXL_MAX) - 1))) - 1) + +#define ANYOF_POSIXL_TEST_ALL_SET(p) \ + ((ANYOF_FLAGS(p) & ANYOF_MATCHES_POSIXL) \ + && ((regnode_charclass_posixl*) (p))->classflags \ + == ((1U << ((ANYOF_POSIXL_MAX) - 1))) - 1) + +#define ANYOF_POSIXL_OR(source, dest) STMT_START { (dest)->classflags |= (source)->classflags ; } STMT_END +#define ANYOF_CLASS_OR(source, dest) ANYOF_POSIXL_OR((source), (dest)) +#define ANYOF_POSIXL_AND(source, dest) STMT_START { (dest)->classflags &= (source)->classflags ; } STMT_END + +#define ANYOF_BITMAP_ZERO(ret) Zero(((struct regnode_charclass*)(ret))->bitmap, ANYOF_BITMAP_SIZE, char) #define ANYOF_BITMAP(p) (((struct regnode_charclass*)(p))->bitmap) #define ANYOF_BITMAP_BYTE(p, c) (ANYOF_BITMAP(p)[(((U8)(c)) >> 3) & 31]) #define ANYOF_BITMAP_SET(p, c) (ANYOF_BITMAP_BYTE(p, c) |= ANYOF_BIT(c)) #define ANYOF_BITMAP_CLEAR(p,c) (ANYOF_BITMAP_BYTE(p, c) &= ~ANYOF_BIT(c)) -#define ANYOF_BITMAP_TEST(p, c) (ANYOF_BITMAP_BYTE(p, c) & ANYOF_BIT(c)) +#define ANYOF_BITMAP_TEST(p, c) cBOOL(ANYOF_BITMAP_BYTE(p, c) & ANYOF_BIT(c)) #define ANYOF_BITMAP_SETALL(p) \ memset (ANYOF_BITMAP(p), 255, ANYOF_BITMAP_SIZE) #define ANYOF_BITMAP_CLEARALL(p) \ Zero (ANYOF_BITMAP(p), ANYOF_BITMAP_SIZE) -/* Check that all 256 bits are all set. Used in S_cl_is_anything() */ -#define ANYOF_BITMAP_TESTALLSET(p) /* Assumes sizeof(p) == 32 */ \ - memEQ (ANYOF_BITMAP(p), "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377", ANYOF_BITMAP_SIZE) - -#define ANYOF_SKIP ((ANYOF_SIZE - 1)/sizeof(regnode)) -#define ANYOF_CLASS_SKIP ((ANYOF_CLASS_SIZE - 1)/sizeof(regnode)) - -#if ANYOF_CLASSBITMAP_SIZE != 4 -# error ANYOF_CLASSBITMAP_SIZE is expected to be 4 -#endif -#define ANYOF_CLASS_TEST_ANY_SET(p) ((ANYOF_FLAGS(p) & ANYOF_CLASS) \ - && memNE (((struct regnode_charclass_class*)(p))->classflags, \ - "\0\0\0\0", ANYOF_CLASSBITMAP_SIZE)) -/*#define ANYOF_CLASS_ADD_SKIP (ANYOF_CLASS_SKIP - ANYOF_SKIP) - * */ +#define ANYOF_SKIP EXTRA_SIZE(struct regnode_charclass) +#define ANYOF_POSIXL_SKIP EXTRA_SIZE(regnode_charclass_posixl) /* * Utility definitions. @@ -494,18 +626,19 @@ struct regnode_charclass_class { #define EXTRA_SIZE(guy) ((sizeof(guy)-1)/sizeof(struct regnode)) -#define REG_SEEN_ZERO_LEN 0x00000001 -#define REG_SEEN_LOOKBEHIND 0x00000002 -#define REG_SEEN_GPOS 0x00000004 +#define REG_ZERO_LEN_SEEN 0x00000001 +#define REG_LOOKBEHIND_SEEN 0x00000002 +#define REG_GPOS_SEEN 0x00000004 /* spare */ -#define REG_SEEN_CANY 0x00000010 -#define REG_SEEN_SANY REG_SEEN_CANY /* src bckwrd cmpt */ -#define REG_SEEN_RECURSE 0x00000020 -#define REG_TOP_LEVEL_BRANCHES 0x00000040 -#define REG_SEEN_VERBARG 0x00000080 -#define REG_SEEN_CUTGROUP 0x00000100 -#define REG_SEEN_RUN_ON_COMMENT 0x00000200 -#define REG_SEEN_EXACTF_SHARP_S 0x00000400 +#define REG_RECURSE_SEEN 0x00000020 +#define REG_TOP_LEVEL_BRANCHES_SEEN 0x00000040 +#define REG_VERBARG_SEEN 0x00000080 +#define REG_CUTGROUP_SEEN 0x00000100 +#define REG_RUN_ON_COMMENT_SEEN 0x00000200 +#define REG_UNFOLDED_MULTI_SEEN 0x00000400 +#define REG_GOSTART_SEEN 0x00000800 +#define REG_UNBOUNDED_QUANTIFIER_SEEN 0x00001000 + START_EXTERN_C @@ -761,6 +894,7 @@ re.pm, especially to the documentation. #define RE_DEBUG_COMPILE_TRIE 0x000004 #define RE_DEBUG_COMPILE_DUMP 0x000008 #define RE_DEBUG_COMPILE_FLAGS 0x000010 +#define RE_DEBUG_COMPILE_TEST 0x000020 /* Execute */ #define RE_DEBUG_EXECUTE_MASK 0x00FF00 @@ -796,6 +930,8 @@ re.pm, especially to the documentation. if (re_debug_flags & RE_DEBUG_COMPILE_TRIE) x ) #define DEBUG_FLAGS_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_COMPILE_FLAGS) x ) +#define DEBUG_TEST_r(x) DEBUG_r( \ + if (re_debug_flags & RE_DEBUG_COMPILE_TEST) x ) /* Execute */ #define DEBUG_EXECUTE_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_EXECUTE_MASK) x ) @@ -836,11 +972,9 @@ re.pm, especially to the documentation. if (re_debug_flags & RE_DEBUG_EXTRA_GPOS) x ) /* initialization */ -/* get_sv() can return NULL during global destruction. re_debug_flags can get - * clobbered by a longjmp, so must be initialized */ +/* get_sv() can return NULL during global destruction. */ #define GET_RE_DEBUG_FLAGS DEBUG_r({ \ SV * re_debug_flags_sv = NULL; \ - re_debug_flags = 0; \ re_debug_flags_sv = get_sv(RE_DEBUG_FLAGS, 1); \ if (re_debug_flags_sv) { \ if (!SvIOK(re_debug_flags_sv)) \ @@ -851,8 +985,8 @@ re.pm, especially to the documentation. #ifdef DEBUGGING -#define GET_RE_DEBUG_FLAGS_DECL VOL IV re_debug_flags \ - PERL_UNUSED_DECL = 0; GET_RE_DEBUG_FLAGS; +#define GET_RE_DEBUG_FLAGS_DECL VOL IV re_debug_flags = 0; \ + PERL_UNUSED_VAR(re_debug_flags); GET_RE_DEBUG_FLAGS; #define RE_PV_COLOR_DECL(rpv,rlen,isuni,dsv,pv,l,m,c1,c2) \ const char * const rpv = \ @@ -889,12 +1023,13 @@ re.pm, especially to the documentation. #endif /* DEBUG RELATED DEFINES */ +typedef enum { + TRADITIONAL_BOUND = _CC_WORDCHAR, + GCB_BOUND, + SB_BOUND, + WB_BOUND +} bound_type; + /* - * Local variables: - * c-indentation-style: bsd - * c-basic-offset: 4 - * indent-tabs-mode: nil - * End: - * * ex: set ts=8 sts=4 sw=4 et: */