X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/78fecfc87dc006b17052d2f8cb36c0a881a19ba5..28d03b21d43611f97565be8d077b7f8eb0bda26a:/regexp.h diff --git a/regexp.h b/regexp.h index 6232356..a86963c 100644 --- a/regexp.h +++ b/regexp.h @@ -18,6 +18,8 @@ /* we don't want to include this stuff if we are inside of an external regex engine based on the core one - like re 'debug'*/ +#include "utf8.h" + struct regnode { U8 flags; U8 type; @@ -44,17 +46,45 @@ struct reg_substr_data { struct reg_substr_datum data[3]; /* Actual array */ }; -#ifdef PERL_OLD_COPY_ON_WRITE +#ifdef PERL_ANY_COW #define SV_SAVED_COPY SV *saved_copy; /* If non-NULL, SV which is COW from original */ #else #define SV_SAVED_COPY #endif +/* offsets within a string of a particular /(.)/ capture */ + typedef struct regexp_paren_pair { I32 start; I32 end; + /* 'start_tmp' records a new opening position before the matching end + * has been found, so that the old start and end values are still + * valid, e.g. + * "abc" =~ /(.(?{print "[$1]"}))+/ + *outputs [][a][b] + * This field is not part of the API. */ + I32 start_tmp; } regexp_paren_pair; +#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C) +#define _invlist_union(a, b, output) _invlist_union_maybe_complement_2nd(a, b, FALSE, output) +#define _invlist_intersection(a, b, output) _invlist_intersection_maybe_complement_2nd(a, b, FALSE, output) + +/* Subtracting b from a leaves in a everything that was there that isn't in b, + * that is the intersection of a with b's complement */ +#define _invlist_subtract(a, b, output) _invlist_intersection_maybe_complement_2nd(a, b, TRUE, output) +#endif + +/* record the position of a (?{...}) within a pattern */ + +struct reg_code_block { + STRLEN start; + STRLEN end; + OP *block; + REGEXP *src_regex; +}; + + /* The regexp/REGEXP struct, see L for further documentation on the individual fields. The struct is ordered so that the most @@ -74,8 +104,8 @@ typedef struct regexp_paren_pair { /* Information about the match that the perl core uses to */ \ /* manage things */ \ U32 extflags; /* Flags used both externally and internally */ \ - I32 minlen; /* mininum possible length of string to match */\ - I32 minlenret; /* mininum possible length of $& */ \ + I32 minlen; /* mininum possible number of chars in string to match */\ + I32 minlenret; /* mininum possible number of chars in $& */ \ U32 gofs; /* chars left of pos that we search from */ \ /* substring data about strings that must appear in the */ \ /* final match, used for optimisations */ \ @@ -89,18 +119,21 @@ typedef struct regexp_paren_pair { /* during matching */ \ U32 lastparen; /* last open paren matched */ \ U32 lastcloseparen; /* last close paren matched */ \ - regexp_paren_pair *swap; /* Unused: 5.10.1 and later */ \ /* Array of offsets for (@-) and (@+) */ \ regexp_paren_pair *offs; \ /* saved or original string so \digit works forever. */ \ char *subbeg; \ SV_SAVED_COPY /* If non-NULL, SV which is COW from original */\ I32 sublen; /* Length of string pointed by subbeg */ \ + I32 suboffset; /* byte offset of subbeg from logical start of str */ \ + I32 subcoffset; /* suboffset equiv, but in chars (for @-/@+) */ \ /* Information about the match that isn't often used */ \ /* offset from wrapped to the start of precomp */ \ PERL_BITFIELD32 pre_prefix:4; \ - /* number of eval groups in the pattern - for security checks */\ - PERL_BITFIELD32 seen_evals:28 + /* original flags used to compile the pattern, may differ */ \ + /* from extflags in various ways */ \ + PERL_BITFIELD32 compflags:9; \ + CV *qr_anoncv /* the anon sub wrapped round qr/(?{..})/ */ typedef struct regexp { _XPV_HEAD; @@ -124,8 +157,13 @@ typedef struct regexp_engine { I32 (*exec) (pTHX_ REGEXP * const rx, char* stringarg, char* strend, char* strbeg, I32 minend, SV* screamer, void* data, U32 flags); - char* (*intuit) (pTHX_ REGEXP * const rx, SV *sv, char *strpos, - char *strend, const U32 flags, + char* (*intuit) (pTHX_ + REGEXP * const rx, + SV *sv, + const char * const strbeg, + char *strpos, + char *strend, + const U32 flags, re_scream_pos_data *data); SV* (*checkstr) (pTHX_ REGEXP * const rx); void (*free) (pTHX_ REGEXP * const rx); @@ -143,6 +181,10 @@ typedef struct regexp_engine { #ifdef USE_ITHREADS void* (*dupe) (pTHX_ REGEXP * const rx, CLONE_PARAMS *param); #endif + REGEXP* (*op_comp) (pTHX_ SV ** const patternp, int pat_count, + OP *expr, const struct regexp_engine* eng, + REGEXP *VOL old_re, + bool *is_bare_re, U32 orig_rx_flags, U32 pm_flags); } regexp_engine; /* @@ -150,9 +192,12 @@ typedef struct regexp_engine { paren name. >= 1 is reserved for actual numbered captures, i.e. $1, $2 etc. */ -#define RX_BUFF_IDX_PREMATCH -2 /* $` / ${^PREMATCH} */ -#define RX_BUFF_IDX_POSTMATCH -1 /* $' / ${^POSTMATCH} */ -#define RX_BUFF_IDX_FULLMATCH 0 /* $& / ${^MATCH} */ +#define RX_BUFF_IDX_CARET_PREMATCH -5 /* ${^PREMATCH} */ +#define RX_BUFF_IDX_CARET_POSTMATCH -4 /* ${^POSTMATCH} */ +#define RX_BUFF_IDX_CARET_FULLMATCH -3 /* ${^MATCH} */ +#define RX_BUFF_IDX_PREMATCH -2 /* $` */ +#define RX_BUFF_IDX_POSTMATCH -1 /* $' */ +#define RX_BUFF_IDX_FULLMATCH 0 /* $& */ /* Flags that are passed to the named_buff and named_buff_iter @@ -190,20 +235,17 @@ equivalent to the following snippet: if (SvMAGICAL(sv)) mg_get(sv); - if (SvROK(sv) && - (tmpsv = (SV*)SvRV(sv)) && - SvTYPE(tmpsv) == SVt_PVMG && - (tmpmg = mg_find(tmpsv, PERL_MAGIC_qr))) - { - return (REGEXP *)tmpmg->mg_obj; - } + if (SvROK(sv)) + sv = MUTABLE_SV(SvRV(sv)); + if (SvTYPE(sv) == SVt_REGEXP) + return (REGEXP*) sv; NULL will be returned if a REGEXP* is not found. =for apidoc Am|bool|SvRXOK|SV* sv -Returns a boolean indicating whether the SV contains qr magic -(PERL_MAGIC_qr). +Returns a boolean indicating whether the SV (or the one it references) +is a REGEXP. If you want to do something with the REGEXP* later use SvRX instead and check for NULL. @@ -218,32 +260,17 @@ and check for NULL. /* Flags stored in regexp->extflags * These are used by code external to the regexp engine * - * Note that flags starting with RXf_PMf_ have exact equivalents - * stored in op_pmflags and which are defined in op.h, they are defined - * numerically here only for clarity. + * Note that the flags whose names start with RXf_PMf_ are defined in + * op_reg_common.h, being copied from the parallel flags of op_pmflags * - * NOTE: if you modify any RXf flags you should run regen.pl or regcomp.pl - * so that regnodes.h is updated with the changes. + * NOTE: if you modify any RXf flags you should run regen.pl or + * regen/regcomp.pl so that regnodes.h is updated with the changes. * */ -/* 0x3F of extflags is used by (RXf_)PMf_COMPILETIME - * If you change these you need to change the equivalent flags in op.h, and -/* vice versa. These need to be ordered so that the msix are contiguous - * starting at bit 0, followed by the p; bit 0 is because of the shift below - * being 0; see STD_PAT_MODS and INT_PAT_MODS below for the contiguity cause */ -/* the flags above are transfered from the PMOP->op_pmflags member during - * compilation */ -#define RXf_PMf_MULTILINE 0x00000001 /* /m */ -#define RXf_PMf_SINGLELINE 0x00000002 /* /s */ -#define RXf_PMf_FOLD 0x00000004 /* /i */ -#define RXf_PMf_EXTENDED 0x00000008 /* /x */ -#define RXf_PMf_KEEPCOPY 0x00000010 /* /p */ -#define RXf_PMf_LOCALE 0x00000020 /* use locale */ -/* these flags are transfered from the PMOP->op_pmflags member during compilation */ -#define RXf_PMf_STD_PMMOD_SHIFT 0 +#include "op_reg_common.h" + #define RXf_PMf_STD_PMMOD (RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_FOLD|RXf_PMf_EXTENDED) -#define RXf_PMf_COMPILETIME (RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_LOCALE|RXf_PMf_FOLD|RXf_PMf_EXTENDED|RXf_PMf_KEEPCOPY) #define CASE_STD_PMMOD_FLAGS_PARSE_SET(pmfl) \ case IGNORE_PAT_MOD: *(pmfl) |= RXf_PMf_FOLD; break; \ @@ -251,13 +278,18 @@ and check for NULL. case SINGLE_PAT_MOD: *(pmfl) |= RXf_PMf_SINGLELINE; break; \ case XTENDED_PAT_MOD: *(pmfl) |= RXf_PMf_EXTENDED; break +/* Note, includes charset ones, assumes 0 is the default for them */ +#define STD_PMMOD_FLAGS_CLEAR(pmfl) \ + *(pmfl) &= ~(RXf_PMf_FOLD|RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_EXTENDED|RXf_PMf_CHARSET) + /* chars and strings used as regex pattern modifiers - * Singlular is a 'c'har, plural is a "string" + * Singular is a 'c'har, plural is a "string" * * NOTE, KEEPCOPY was originally 'k', but was changed to 'p' for preserve * for compatibility reasons with Regexp::Common which highjacked (?k:...) * for its own uses. So 'k' is out as well. */ +#define DEFAULT_PAT_MOD '^' /* Short for all the default modifiers */ #define EXEC_PAT_MOD 'e' #define KEEPCOPY_PAT_MOD 'p' #define ONCE_PAT_MOD 'o' @@ -268,94 +300,163 @@ and check for NULL. #define IGNORE_PAT_MOD 'i' #define XTENDED_PAT_MOD 'x' #define NONDESTRUCT_PAT_MOD 'r' +#define LOCALE_PAT_MOD 'l' +#define UNICODE_PAT_MOD 'u' +#define DEPENDS_PAT_MOD 'd' +#define ASCII_RESTRICT_PAT_MOD 'a' #define ONCE_PAT_MODS "o" #define KEEPCOPY_PAT_MODS "p" #define EXEC_PAT_MODS "e" #define LOOP_PAT_MODS "gc" #define NONDESTRUCT_PAT_MODS "r" +#define LOCALE_PAT_MODS "l" +#define UNICODE_PAT_MODS "u" +#define DEPENDS_PAT_MODS "d" +#define ASCII_RESTRICT_PAT_MODS "a" +#define ASCII_MORE_RESTRICT_PAT_MODS "aa" /* This string is expected by regcomp.c to be ordered so that the first - * character is the flag in bit 0 of extflags; the next character is bit 1, - * etc. */ + * character is the flag in bit RXf_PMf_STD_PMMOD_SHIFT of extflags; the next + * character is bit +1, etc. */ #define STD_PAT_MODS "msix" +#define CHARSET_PAT_MODS ASCII_RESTRICT_PAT_MODS DEPENDS_PAT_MODS LOCALE_PAT_MODS UNICODE_PAT_MODS + /* This string is expected by XS_re_regexp_pattern() in universal.c to be ordered - * so that the first character is the flag in bit 0 of extflags; the next - * character is bit 1, etc. */ + * so that the first character is the flag in bit RXf_PMf_STD_PMMOD_SHIFT of + * extflags; the next character is in bit +1, etc. */ #define INT_PAT_MODS STD_PAT_MODS KEEPCOPY_PAT_MODS #define EXT_PAT_MODS ONCE_PAT_MODS KEEPCOPY_PAT_MODS -#define QR_PAT_MODS STD_PAT_MODS EXT_PAT_MODS +#define QR_PAT_MODS STD_PAT_MODS EXT_PAT_MODS CHARSET_PAT_MODS #define M_PAT_MODS QR_PAT_MODS LOOP_PAT_MODS #define S_PAT_MODS M_PAT_MODS EXEC_PAT_MODS NONDESTRUCT_PAT_MODS /* - * NOTE: if you modify any RXf flags you should run regen.pl or regcomp.pl - * so that regnodes.h is updated with the changes. + * NOTE: if you modify any RXf flags you should run regen.pl or + * regen/regcomp.pl so that regnodes.h is updated with the changes. * */ +/* Leave some space, so future bit allocations can go either in the shared or + * unshared area without affecting binary compatibility */ +#define RXf_BASE_SHIFT (_RXf_PMf_SHIFT_NEXT) + +/* + Set in Perl_pmruntime if op_flags & OPf_SPECIAL, i.e. split. Will + be used by regex engines to check whether they should set + RXf_SKIPWHITE +*/ +#define RXf_SPLIT (1<<(RXf_BASE_SHIFT-1)) +#if RXf_SPLIT != RXf_PMf_SPLIT +# error "RXf_SPLIT does not match RXf_PMf_SPLIT" +#endif + +/* Manually decorate this function with gcc-style attributes just to + * avoid having to restructure the header files and their called order, + * as proto.h would have to be included before this file, and isn't */ + +PERL_STATIC_INLINE const char * +get_regex_charset_name(const U32 flags, STRLEN* const lenp) + __attribute__warn_unused_result__; + +#define MAX_CHARSET_NAME_LENGTH 2 + +PERL_STATIC_INLINE const char * +get_regex_charset_name(const U32 flags, STRLEN* const lenp) +{ + /* Returns a string that corresponds to the name of the regex character set + * given by 'flags', and *lenp is set the length of that string, which + * cannot exceed MAX_CHARSET_NAME_LENGTH characters */ + + *lenp = 1; + switch (get_regex_charset(flags)) { + case REGEX_DEPENDS_CHARSET: return DEPENDS_PAT_MODS; + case REGEX_LOCALE_CHARSET: return LOCALE_PAT_MODS; + case REGEX_UNICODE_CHARSET: return UNICODE_PAT_MODS; + case REGEX_ASCII_RESTRICTED_CHARSET: return ASCII_RESTRICT_PAT_MODS; + case REGEX_ASCII_MORE_RESTRICTED_CHARSET: + *lenp = 2; + return ASCII_MORE_RESTRICT_PAT_MODS; + default: + return "?"; /* Unknown */ + } +} + /* Anchor and GPOS related stuff */ -#define RXf_ANCH_BOL 0x00000100 -#define RXf_ANCH_MBOL 0x00000200 -#define RXf_ANCH_SBOL 0x00000400 -#define RXf_ANCH_GPOS 0x00000800 -#define RXf_GPOS_SEEN 0x00001000 -#define RXf_GPOS_FLOAT 0x00002000 +#define RXf_ANCH_BOL (1<<(RXf_BASE_SHIFT+0)) +#define RXf_ANCH_MBOL (1<<(RXf_BASE_SHIFT+1)) +#define RXf_ANCH_SBOL (1<<(RXf_BASE_SHIFT+2)) +#define RXf_ANCH_GPOS (1<<(RXf_BASE_SHIFT+3)) +#define RXf_GPOS_SEEN (1<<(RXf_BASE_SHIFT+4)) +#define RXf_GPOS_FLOAT (1<<(RXf_BASE_SHIFT+5)) /* two bits here */ #define RXf_ANCH (RXf_ANCH_BOL|RXf_ANCH_MBOL|RXf_ANCH_GPOS|RXf_ANCH_SBOL) #define RXf_GPOS_CHECK (RXf_GPOS_SEEN|RXf_ANCH_GPOS) #define RXf_ANCH_SINGLE (RXf_ANCH_SBOL|RXf_ANCH_GPOS) /* What we have seen */ -#define RXf_LOOKBEHIND_SEEN 0x00004000 -#define RXf_EVAL_SEEN 0x00008000 -#define RXf_CANY_SEEN 0x00010000 +#define RXf_NO_INPLACE_SUBST (1<<(RXf_BASE_SHIFT+6)) +#define RXf_EVAL_SEEN (1<<(RXf_BASE_SHIFT+7)) +#define RXf_CANY_SEEN (1<<(RXf_BASE_SHIFT+8)) /* Special */ -#define RXf_NOSCAN 0x00020000 -#define RXf_CHECK_ALL 0x00040000 +#define RXf_NOSCAN (1<<(RXf_BASE_SHIFT+9)) +#define RXf_CHECK_ALL (1<<(RXf_BASE_SHIFT+10)) /* UTF8 related */ -#define RXf_MATCH_UTF8 0x00100000 +#define RXf_MATCH_UTF8 (1<<(RXf_BASE_SHIFT+11)) /* $1 etc are utf8 */ /* Intuit related */ -#define RXf_USE_INTUIT_NOML 0x00200000 -#define RXf_USE_INTUIT_ML 0x00400000 -#define RXf_INTUIT_TAIL 0x00800000 - -/* - Set in Perl_pmruntime if op_flags & OPf_SPECIAL, i.e. split. Will - be used by regex engines to check whether they should set - RXf_SKIPWHITE -*/ -#define RXf_SPLIT 0x01000000 - +#define RXf_USE_INTUIT_NOML (1<<(RXf_BASE_SHIFT+12)) +#define RXf_USE_INTUIT_ML (1<<(RXf_BASE_SHIFT+13)) +#define RXf_INTUIT_TAIL (1<<(RXf_BASE_SHIFT+14)) #define RXf_USE_INTUIT (RXf_USE_INTUIT_NOML|RXf_USE_INTUIT_ML) /* Copy and tainted info */ -#define RXf_COPY_DONE 0x02000000 -#define RXf_TAINTED_SEEN 0x04000000 -#define RXf_TAINTED 0x08000000 /* this pattern is tainted */ +#define RXf_COPY_DONE (1<<(RXf_BASE_SHIFT+16)) + +/* during execution: pattern temporarily tainted by executing locale ops; + * post-execution: $1 et al are tainted */ +#define RXf_TAINTED_SEEN (1<<(RXf_BASE_SHIFT+17)) +/* this pattern was tainted during compilation */ +#define RXf_TAINTED (1<<(RXf_BASE_SHIFT+18)) /* Flags indicating special patterns */ -#define RXf_START_ONLY 0x10000000 /* Pattern is /^/ */ -#define RXf_SKIPWHITE 0x20000000 /* Pattern is for a split / / */ -#define RXf_WHITE 0x40000000 /* Pattern is /\s+/ */ -#define RXf_NULL 0x80000000 /* Pattern is // */ +#define RXf_START_ONLY (1<<(RXf_BASE_SHIFT+19)) /* Pattern is /^/ */ +#define RXf_SKIPWHITE (1<<(RXf_BASE_SHIFT+20)) /* Pattern is for a split " " */ +#define RXf_WHITE (1<<(RXf_BASE_SHIFT+21)) /* Pattern is /\s+/ */ +#define RXf_NULL (1U<<(RXf_BASE_SHIFT+22)) /* Pattern is // */ +#if RXf_BASE_SHIFT+22 > 31 +# error Too many RXf_PMf bits used. See regnodes.h for any spare in middle +#endif /* - * NOTE: if you modify any RXf flags you should run regen.pl or regcomp.pl - * so that regnodes.h is updated with the changes. + * NOTE: if you modify any RXf flags you should run regen.pl or + * regen/regcomp.pl so that regnodes.h is updated with the changes. * */ +#if NO_TAINT_SUPPORT +# define RX_ISTAINTED(prog) 0 +# define RX_TAINT_on(prog) NOOP +# define RXp_MATCH_TAINTED(prog) 0 +# define RX_MATCH_TAINTED(prog) 0 +# define RXp_MATCH_TAINTED_on(prog) NOOP +# define RX_MATCH_TAINTED_on(prog) NOOP +# define RX_MATCH_TAINTED_off(prog) NOOP +#else +# define RX_ISTAINTED(prog) (RX_EXTFLAGS(prog) & RXf_TAINTED) +# define RX_TAINT_on(prog) (RX_EXTFLAGS(prog) |= RXf_TAINTED) +# define RXp_MATCH_TAINTED(prog) (RXp_EXTFLAGS(prog) & RXf_TAINTED_SEEN) +# define RX_MATCH_TAINTED(prog) (RX_EXTFLAGS(prog) & RXf_TAINTED_SEEN) +# define RXp_MATCH_TAINTED_on(prog) (RXp_EXTFLAGS(prog) |= RXf_TAINTED_SEEN) +# define RX_MATCH_TAINTED_on(prog) (RX_EXTFLAGS(prog) |= RXf_TAINTED_SEEN) +# define RX_MATCH_TAINTED_off(prog) (RX_EXTFLAGS(prog) &= ~RXf_TAINTED_SEEN) +#endif + #define RX_HAS_CUTGROUP(prog) ((prog)->intflags & PREGf_CUTGROUP_SEEN) -#define RXp_MATCH_TAINTED(prog) (RXp_EXTFLAGS(prog) & RXf_TAINTED_SEEN) -#define RX_MATCH_TAINTED(prog) (RX_EXTFLAGS(prog) & RXf_TAINTED_SEEN) -#define RX_MATCH_TAINTED_on(prog) (RX_EXTFLAGS(prog) |= RXf_TAINTED_SEEN) -#define RX_MATCH_TAINTED_off(prog) (RX_EXTFLAGS(prog) &= ~RXf_TAINTED_SEEN) #define RX_MATCH_TAINTED_set(prog, t) ((t) \ ? RX_MATCH_TAINTED_on(prog) \ : RX_MATCH_TAINTED_off(prog)) @@ -371,71 +472,41 @@ and check for NULL. : RX_MATCH_COPIED_off(prog)) #define RXp_EXTFLAGS(rx) ((rx)->extflags) +#define RXp_COMPFLAGS(rx) ((rx)->compflags) /* For source compatibility. We used to store these explicitly. */ -#define RX_PRECOMP(prog) (RX_WRAPPED(prog) + ((struct regexp *)SvANY(prog))->pre_prefix) -#define RX_PRECOMP_const(prog) (RX_WRAPPED_const(prog) + ((struct regexp *)SvANY(prog))->pre_prefix) +#define RX_PRECOMP(prog) (RX_WRAPPED(prog) + ReANY(prog)->pre_prefix) +#define RX_PRECOMP_const(prog) (RX_WRAPPED_const(prog) + ReANY(prog)->pre_prefix) /* FIXME? Are we hardcoding too much here and constraining plugin extension writers? Specifically, the value 1 assumes that the wrapped version always has exactly one character at the end, a ')'. Will that always be true? */ -#define RX_PRELEN(prog) (RX_WRAPLEN(prog) - ((struct regexp *)SvANY(prog))->pre_prefix - 1) -#define RX_WRAPPED(prog) SvPVX(prog) -#define RX_WRAPPED_const(prog) SvPVX_const(prog) +#define RX_PRELEN(prog) (RX_WRAPLEN(prog) - ReANY(prog)->pre_prefix - 1) +#define RX_WRAPPED(prog) ReANY(prog)->xpv_len_u.xpvlenu_pv +#define RX_WRAPPED_const(prog) ((const char *)RX_WRAPPED(prog)) #define RX_WRAPLEN(prog) SvCUR(prog) -#define RX_CHECK_SUBSTR(prog) (((struct regexp *)SvANY(prog))->check_substr) +#define RX_CHECK_SUBSTR(prog) (ReANY(prog)->check_substr) #define RX_REFCNT(prog) SvREFCNT(prog) -#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) -# define RX_EXTFLAGS(prog) \ - (*({ \ - const REGEXP *const _rx_extflags = (prog); \ - assert(SvTYPE(_rx_extflags) == SVt_REGEXP); \ - &RXp_EXTFLAGS(SvANY(_rx_extflags)); \ - })) -# define RX_ENGINE(prog) \ - (*({ \ - const REGEXP *const _rx_engine = (prog); \ - assert(SvTYPE(_rx_engine) == SVt_REGEXP); \ - &SvANY(_rx_engine)->engine; \ - })) -# define RX_SUBBEG(prog) \ - (*({ \ - const REGEXP *const _rx_subbeg = (prog); \ - assert(SvTYPE(_rx_subbeg) == SVt_REGEXP); \ - &SvANY(_rx_subbeg)->subbeg; \ - })) -# define RX_OFFS(prog) \ - (*({ \ - const REGEXP *const _rx_offs = (prog); \ - assert(SvTYPE(_rx_offs) == SVt_REGEXP); \ - &SvANY(_rx_offs)->offs; \ - })) -# define RX_NPARENS(prog) \ - (*({ \ - const REGEXP *const _rx_nparens = (prog); \ - assert(SvTYPE(_rx_nparens) == SVt_REGEXP); \ - &SvANY(_rx_nparens)->nparens; \ - })) -#else -# define RX_EXTFLAGS(prog) RXp_EXTFLAGS((struct regexp *)SvANY(prog)) -# define RX_ENGINE(prog) (((struct regexp *)SvANY(prog))->engine) -# define RX_SUBBEG(prog) (((struct regexp *)SvANY(prog))->subbeg) -# define RX_OFFS(prog) (((struct regexp *)SvANY(prog))->offs) -# define RX_NPARENS(prog) (((struct regexp *)SvANY(prog))->nparens) -#endif -#define RX_SUBLEN(prog) (((struct regexp *)SvANY(prog))->sublen) -#define RX_MINLEN(prog) (((struct regexp *)SvANY(prog))->minlen) -#define RX_MINLENRET(prog) (((struct regexp *)SvANY(prog))->minlenret) -#define RX_GOFS(prog) (((struct regexp *)SvANY(prog))->gofs) -#define RX_LASTPAREN(prog) (((struct regexp *)SvANY(prog))->lastparen) -#define RX_LASTCLOSEPAREN(prog) (((struct regexp *)SvANY(prog))->lastcloseparen) -#define RX_SEEN_EVALS(prog) (((struct regexp *)SvANY(prog))->seen_evals) -#define RX_SAVED_COPY(prog) (((struct regexp *)SvANY(prog))->saved_copy) +#define RX_EXTFLAGS(prog) RXp_EXTFLAGS(ReANY(prog)) +#define RX_COMPFLAGS(prog) RXp_COMPFLAGS(ReANY(prog)) +#define RX_ENGINE(prog) (ReANY(prog)->engine) +#define RX_SUBBEG(prog) (ReANY(prog)->subbeg) +#define RX_SUBOFFSET(prog) (ReANY(prog)->suboffset) +#define RX_SUBCOFFSET(prog) (ReANY(prog)->subcoffset) +#define RX_OFFS(prog) (ReANY(prog)->offs) +#define RX_NPARENS(prog) (ReANY(prog)->nparens) +#define RX_SUBLEN(prog) (ReANY(prog)->sublen) +#define RX_MINLEN(prog) (ReANY(prog)->minlen) +#define RX_MINLENRET(prog) (ReANY(prog)->minlenret) +#define RX_GOFS(prog) (ReANY(prog)->gofs) +#define RX_LASTPAREN(prog) (ReANY(prog)->lastparen) +#define RX_LASTCLOSEPAREN(prog) (ReANY(prog)->lastcloseparen) +#define RX_SAVED_COPY(prog) (ReANY(prog)->saved_copy) #endif /* PLUGGABLE_RE_EXTENSION */ -/* Stuff that needs to be included in the plugable extension goes below here */ +/* Stuff that needs to be included in the pluggable extension goes below here */ -#ifdef PERL_OLD_COPY_ON_WRITE +#ifdef PERL_ANY_COW #define RX_MATCH_COPY_FREE(rx) \ STMT_START {if (RX_SAVED_COPY(rx)) { \ SV_CHECK_THINKFIRST_COW_DROP(RX_SAVED_COPY(rx)); \ @@ -457,8 +528,8 @@ and check for NULL. #define RX_MATCH_UTF8_on(prog) (RX_EXTFLAGS(prog) |= RXf_MATCH_UTF8) #define RX_MATCH_UTF8_off(prog) (RX_EXTFLAGS(prog) &= ~RXf_MATCH_UTF8) #define RX_MATCH_UTF8_set(prog, t) ((t) \ - ? (RX_MATCH_UTF8_on(prog), (PL_reg_match_utf8 = 1)) \ - : (RX_MATCH_UTF8_off(prog), (PL_reg_match_utf8 = 0))) + ? RX_MATCH_UTF8_on(prog) \ + : RX_MATCH_UTF8_off(prog)) /* Whether the pattern stored at RX_WRAPPED is in UTF-8 */ #define RX_UTF8(prog) SvUTF8(prog) @@ -468,6 +539,11 @@ and check for NULL. #define REXEC_SCREAM 0x04 /* use scream table. */ #define REXEC_IGNOREPOS 0x08 /* \G matches at start. */ #define REXEC_NOT_FIRST 0x10 /* This is another iteration of //g. */ + /* under REXEC_COPY_STR, it's ok for the + * engine (modulo PL_sawamperand etc) + * to skip copying ... */ +#define REXEC_COPY_SKIP_PRE 0x20 /* ...the $` part of the string, or */ +#define REXEC_COPY_SKIP_POST 0x40 /* ...the $' part of the string */ #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define ReREFCNT_inc(re) \ @@ -488,6 +564,7 @@ and check for NULL. # define ReREFCNT_dec(re) SvREFCNT_dec(re) # define ReREFCNT_inc(re) ((REGEXP *) SvREFCNT_inc(re)) #endif +#define ReANY(re) S_ReANY((const REGEXP *)(re)) /* FIXME for plugins. */ @@ -499,16 +576,64 @@ and check for NULL. #define FBMrf_MULTILINE 1 +struct regmatch_state; +struct regmatch_slab; + +/* like regmatch_info_aux, but contains extra fields only needed if the + * pattern contains (?{}). If used, is snuck into the second slot in the + * regmatch_state stack at the start of execution */ + +typedef struct { + regexp *rex; + PMOP *curpm; /* saved PL_curpm */ +#ifdef PERL_ANY_COW + SV *saved_copy; /* saved saved_copy field from rex */ +#endif + char *subbeg; /* saved subbeg field from rex */ + STRLEN sublen; /* saved sublen field from rex */ + STRLEN suboffset; /* saved suboffset field from rex */ + STRLEN subcoffset; /* saved subcoffset field from rex */ + MAGIC *pos_magic; /* pos() magic attached to $_ */ + I32 pos; /* the original value of pos() in pos_magic */ +} regmatch_info_aux_eval; + + +/* fields that logically live in regmatch_info, but which need cleaning + * up on croak(), and so are instead are snuck into the first slot in + * the regmatch_state stack at the start of execution */ + +typedef struct { + regmatch_info_aux_eval *info_aux_eval; + struct regmatch_state *old_regmatch_state; /* saved PL_regmatch_state */ + struct regmatch_slab *old_regmatch_slab; /* saved PL_regmatch_slab */ + char *poscache; /* S-L cache of fail positions of WHILEMs */ +} regmatch_info_aux; + + /* some basic information about the current match that is created by - * Perl_regexec_flags and then passed to regtry(), regmatch() etc */ + * Perl_regexec_flags and then passed to regtry(), regmatch() etc. + * It is allocated as a local var on the stack, so nothing should be + * stored in it that needs preserving or clearing up on croak(). + * For that, see the aux_info and aux_info_eval members of the + * regmatch_state union. */ typedef struct { - REGEXP *prog; - char *bol; - char *till; - SV *sv; - char *ganch; - char *cutpoint; + REGEXP *prog; /* the regex being executed */ + const char * strbeg; /* real start of string */ + char *strend; /* one byte beyond last char of match string */ + char *till; /* matches shorter than this fail (see minlen arg) */ + SV *sv; /* the SV string currently being matched */ + char *ganch; /* position of \G anchor */ + char *cutpoint; /* (*COMMIT) position (if any) */ + regmatch_info_aux *info_aux; /* extra fields that need cleanup */ + regmatch_info_aux_eval *info_aux_eval; /* extra saved state for (?{}) */ + I32 poscache_maxiter; /* how many whilems todo before S-L cache kicks in */ + I32 poscache_iter; /* current countdown from _maxiter to zero */ + STRLEN poscache_size; /* size of regmatch_info_aux.poscache */ + bool intuit; /* re_intuit_start() is the top-level caller */ + bool is_utf8_pat; /* regex is utf8 */ + bool is_utf8_target; /* string being matched is utf8 */ + bool warned; /* we have issued a recursion warning; no need for more */ } regmatch_info; @@ -526,6 +651,29 @@ typedef struct regmatch_state { union { + /* the 'info_aux' and 'info_aux_eval' union members are cuckoos in + * the nest. They aren't saved backtrack state; rather they + * represent one or two extra chunks of data that need allocating + * at the start of a match. These fields would logically live in + * the regmatch_info struct, except that is allocated on the + * C stack, and these fields are all things that require cleanup + * after a croak(), when the stack is lost. + * As a convenience, we just use the first 1 or 2 regmatch_state + * slots to store this info, as we will be allocating a slab of + * these anyway. Otherwise we'd have to malloc and then free them, + * or allocate them on the save stack (where they will get + * realloced if the save stack grows). + * info_aux contains the extra fields that are always needed; + * info_aux_eval contains extra fields that only needed if + * the pattern contains code blocks + * We split them into two separate structs to avoid increasing + * the size of the union. + */ + + regmatch_info_aux info_aux; + + regmatch_info_aux_eval info_aux_eval; + /* this is a fake union member that matches the first element * of each member that needs to store positive backtrack * information */ @@ -540,6 +688,7 @@ typedef struct regmatch_state { /* this first element must match u.yes */ struct regmatch_state *prev_yes_state; U32 lastparen; + U32 lastcloseparen; CHECKPOINT cp; } branchlike; @@ -548,6 +697,7 @@ typedef struct regmatch_state { /* the first elements must match u.branchlike */ struct regmatch_state *prev_yes_state; U32 lastparen; + U32 lastcloseparen; CHECKPOINT cp; regnode *next_branch; /* next branch node */ @@ -557,17 +707,17 @@ typedef struct regmatch_state { /* the first elements must match u.branchlike */ struct regmatch_state *prev_yes_state; U32 lastparen; + U32 lastcloseparen; CHECKPOINT cp; U32 accepted; /* how many accepting states left */ + bool longfold;/* saw a fold with a 1->n char mapping */ U16 *jump; /* positive offsets from me */ - regnode *B; /* node following the trie */ regnode *me; /* Which node am I - needed for jump tries*/ U8 *firstpos;/* pos in string of first trie match */ U32 firstchars;/* len in chars of firstpos from start */ U16 nextword;/* next word to try */ U16 topword; /* longest accepted word */ - bool longfold;/* saw a fold with a 1->n char mapping */ } trie; /* special types - these members are used to store state for special @@ -578,9 +728,6 @@ typedef struct regmatch_state { struct regmatch_state *prev_eval; struct regmatch_state *prev_curlyx; REGEXP *prev_rex; - U32 toggle_reg_flags; /* what bits in PL_reg_flags to - flip when transitioning between - inner and outer rexen */ CHECKPOINT cp; /* remember current savestack indexes */ CHECKPOINT lastcp; U32 close_paren; /* which close bracket is our end */ @@ -638,24 +785,32 @@ typedef struct regmatch_state { struct { /* this first element must match u.yes */ struct regmatch_state *prev_yes_state; - I32 c1, c2; /* case fold search */ + int c1, c2; /* case fold search */ CHECKPOINT cp; + U32 lastparen; + U32 lastcloseparen; I32 alen; /* length of first-matched A string */ I32 count; bool minmod; regnode *A, *B; /* the nodes corresponding to /A*B/ */ regnode *me; /* the curlym node */ + U8 c1_utf8[UTF8_MAXBYTES+1]; /* */ + U8 c2_utf8[UTF8_MAXBYTES+1]; } curlym; struct { U32 paren; CHECKPOINT cp; - I32 c1, c2; /* case fold search */ + U32 lastparen; + U32 lastcloseparen; + int c1, c2; /* case fold search */ char *maxpos; /* highest possible point in string to match */ char *oldloc; /* the previous locinput */ int count; int min, max; /* {m,n} */ regnode *A, *B; /* the nodes corresponding to /A*B/ */ + U8 c1_utf8[UTF8_MAXBYTES+1]; /* */ + U8 c2_utf8[UTF8_MAXBYTES+1]; } curly; /* and CURLYN/PLUS/STAR */ } u; @@ -673,69 +828,14 @@ typedef struct regmatch_slab { struct regmatch_slab *prev, *next; } regmatch_slab; -#define PL_reg_flags PL_reg_state.re_state_reg_flags -#define PL_bostr PL_reg_state.re_state_bostr -#define PL_reginput PL_reg_state.re_state_reginput -#define PL_regeol PL_reg_state.re_state_regeol -#define PL_regoffs PL_reg_state.re_state_regoffs -#define PL_reglastparen PL_reg_state.re_state_reglastparen -#define PL_reglastcloseparen PL_reg_state.re_state_reglastcloseparen -#define PL_reg_start_tmp PL_reg_state.re_state_reg_start_tmp -#define PL_reg_start_tmpl PL_reg_state.re_state_reg_start_tmpl -#define PL_reg_eval_set PL_reg_state.re_state_reg_eval_set -#define PL_reg_match_utf8 PL_reg_state.re_state_reg_match_utf8 -#define PL_reg_magic PL_reg_state.re_state_reg_magic -#define PL_reg_oldpos PL_reg_state.re_state_reg_oldpos -#define PL_reg_oldcurpm PL_reg_state.re_state_reg_oldcurpm -#define PL_reg_curpm PL_reg_state.re_state_reg_curpm -#define PL_reg_oldsaved PL_reg_state.re_state_reg_oldsaved -#define PL_reg_oldsavedlen PL_reg_state.re_state_reg_oldsavedlen -#define PL_reg_maxiter PL_reg_state.re_state_reg_maxiter -#define PL_reg_leftiter PL_reg_state.re_state_reg_leftiter -#define PL_reg_poscache PL_reg_state.re_state_reg_poscache -#define PL_reg_poscache_size PL_reg_state.re_state_reg_poscache_size -#define PL_regsize PL_reg_state.re_state_regsize -#define PL_reg_starttry PL_reg_state.re_state_reg_starttry -#define PL_nrs PL_reg_state.re_state_nrs - -struct re_save_state { - U32 re_state_reg_flags; /* from regexec.c */ - U32 re_state_reg_start_tmpl; /* from regexec.c */ - I32 re_state_reg_eval_set; /* from regexec.c */ - bool re_state_reg_match_utf8; /* from regexec.c */ - char *re_state_bostr; - char *re_state_reginput; /* String-input pointer. */ - char *re_state_regeol; /* End of input, for $ check. */ - regexp_paren_pair *re_state_regoffs; /* Pointer to start/end pairs */ - U32 *re_state_reglastparen; /* Similarly for lastparen. */ - U32 *re_state_reglastcloseparen; /* Similarly for lastcloseparen. */ - char **re_state_reg_start_tmp; /* from regexec.c */ - MAGIC *re_state_reg_magic; /* from regexec.c */ - PMOP *re_state_reg_oldcurpm; /* from regexec.c */ - PMOP *re_state_reg_curpm; /* from regexec.c */ - char *re_state_reg_oldsaved; /* old saved substr during match */ - STRLEN re_state_reg_oldsavedlen; /* old length of saved substr during match */ - STRLEN re_state_reg_poscache_size; /* size of pos cache of WHILEM */ - I32 re_state_reg_oldpos; /* from regexec.c */ - I32 re_state_reg_maxiter; /* max wait until caching pos */ - I32 re_state_reg_leftiter; /* wait until caching pos */ - U32 re_state_regsize; /* from regexec.c */ - char *re_state_reg_poscache; /* cache of pos of WHILEM */ - char *re_state_reg_starttry; /* from regexec.c */ -#ifdef PERL_OLD_COPY_ON_WRITE - SV *re_state_nrs; /* was placeholder: unused since 5.8.0 (5.7.2 patch #12027 for bug ID 20010815.012). Used to save rx->saved_copy */ -#endif -}; -#define SAVESTACK_ALLOC_FOR_RE_SAVE_STATE \ - (1 + ((sizeof(struct re_save_state) - 1) / sizeof(*PL_savestack))) /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */