/* regexp.h
*
* Copyright (C) 1993, 1994, 1996, 1997, 1999, 2000, 2001, 2003,
- * 2005, 2006, 2007, by Larry Wall and others
+ * 2005, 2006, 2007, 2008 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
#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<perlreapi> for further documentation
on the individual fields. The struct is ordered so that the most
regexp's data array based on the data item's type.
*/
+#define _REGEXP_COMMON \
+ /* what engine created this regexp? */ \
+ const struct regexp_engine* engine; \
+ REGEXP *mother_re; /* what re is this a lightweight copy of? */ \
+ HV *paren_names; /* Optional hash of paren names */ \
+ /* 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 $& */ \
+ U32 gofs; /* chars left of pos that we search from */ \
+ /* substring data about strings that must appear in the */ \
+ /* final match, used for optimisations */ \
+ struct reg_substr_data *substrs; \
+ U32 nparens; /* number of capture buffers */ \
+ /* private engine specific data */ \
+ U32 intflags; /* Engine Specific Internal flags */ \
+ void *pprivate; /* Data private to the regex engine which */ \
+ /* created this object. */ \
+ /* Data about the last/current match. These are modified */ \
+ /* 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; \
+ CV *qr_anoncv /* the anon sub wrapped round qr/(?{..})/ */
+
typedef struct regexp {
_XPV_HEAD;
- _XPVMG_HEAD;
- /* what engine created this regexp? */
- const struct regexp_engine* engine;
- REGEXP *mother_re; /* what re is this a lightweight copy of? */
-
- /* 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 $& */
- U32 gofs; /* chars left of pos that we search from */
- struct reg_substr_data *substrs; /* substring data about strings that must appear
- in the final match, used for optimisations */
- U32 nparens; /* number of capture buffers */
-
- /* private engine specific data */
- U32 intflags; /* Engine Specific Internal flags */
- void *pprivate; /* Data private to the regex engine which
- created this object. */
-
- /* Data about the last/current match. These are modified during matching*/
- U32 lastparen; /* last open paren matched */
- U32 lastcloseparen; /* last close paren matched */
- regexp_paren_pair *swap; /* Swap copy of *offs */
- regexp_paren_pair *offs; /* Array of offsets for (@-) and (@+) */
-
- char *subbeg; /* saved or original string
- so \digit works forever. */
- SV_SAVED_COPY /* If non-NULL, SV which is COW from original */
- I32 sublen; /* Length of string pointed by subbeg */
-
-
- /* Information about the match that isn't often used */
- /* wrapped can't be const char*, as it is returned by sv_2pv_flags */
- char *wrapped; /* wrapped version of the pattern */
- I32 wraplen; /* length of wrapped */
- unsigned pre_prefix:4; /* offset from wrapped to the start of precomp */
- unsigned seen_evals:28; /* number of eval groups in the pattern - for security checks */
- HV *paren_names; /* Optional hash of paren names */
+ _REGEXP_COMMON;
} regexp;
+#define RXp_PAREN_NAMES(rx) ((rx)->paren_names)
+
/* used for high speed searches */
typedef struct re_scream_pos_data_s
{
* Any regex engine implementation must be able to build one of these.
*/
typedef struct regexp_engine {
- REGEXP* (*comp) (pTHX_ const SV * const pattern, const U32 flags);
+ REGEXP* (*comp) (pTHX_ SV * const pattern, U32 flags);
I32 (*exec) (pTHX_ REGEXP * const rx, char* stringarg, char* strend,
char* strbeg, I32 minend, SV* screamer,
void* data, U32 flags);
#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;
/*
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
/* Whether this is being called from a re:: function */
#define RXapif_REGNAME 0x0400
#define RXapif_REGNAMES 0x0800
-#define RXapif_REGNAMES_COUNT 0x1000
+#define RXapif_REGNAMES_COUNT 0x1000
/*
=head1 REGEXP Functions
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.
#define SvRXOK(sv) (Perl_get_re_arg(aTHX_ sv) ? TRUE : FALSE)
-/* Flags stored in regexp->extflags
+/* 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. */
-#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; \
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'
#define SINGLE_PAT_MOD 's'
#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 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 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
+#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+1)
+
+/* 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_LOOKBEHIND_SEEN (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_UTF8 0x00080000
-#define RXf_MATCH_UTF8 0x00100000
+#define RXf_MATCH_UTF8 (1<<(RXf_BASE_SHIFT+11))
/* Intuit related */
-#define RXf_USE_INTUIT_NOML 0x00200000
-#define RXf_USE_INTUIT_ML 0x00400000
-#define RXf_INTUIT_TAIL 0x00800000
+#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))
/*
- 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
+ This used to be set in Perl_pmruntime if op_flags & OPf_SPECIAL, i.e.
+ split. It was used by the regex engine to check whether it should set
+ RXf_SKIPWHITE. Regexp plugins on CPAN also have done the same thing
+ historically, so we leave this flag defined, even though it is never set.
*/
-#define RXf_SPLIT 0x01000000
+#if !defined(PERL_CORE) || defined(PERL_IN_DUMP_C)
+# define RXf_SPLIT (1<<(RXf_BASE_SHIFT+15))
+#endif
#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 /^/ */
+/* No longer used, but CPAN modules still mention it. */
+#if !defined(PERL_CORE) || defined(PERL_IN_DUMP_C)
+# define RXf_SKIPWHITE (1<<(RXf_BASE_SHIFT+20)) /* Pattern is for a split " " */
+#endif
+#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.
*
*/
? RX_MATCH_COPIED_on(prog) \
: RX_MATCH_COPIED_off(prog))
-#define RXp_PRECOMP(rx) ((rx)->wrapped + (rx)->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 RXp_PRELEN(rx) ((rx)->wraplen - (rx)->pre_prefix - 1)
-#define RXp_WRAPPED(rx) ((rx)->wrapped)
-#define RXp_WRAPLEN(rx) ((rx)->wraplen)
#define RXp_EXTFLAGS(rx) ((rx)->extflags)
/* For source compatibility. We used to store these explicitly. */
-#define RX_PRECOMP(prog) RXp_PRECOMP((struct regexp *)SvANY(prog))
-#define RX_PRELEN(prog) RXp_PRELEN((struct regexp *)SvANY(prog))
-#define RX_WRAPPED(prog) RXp_WRAPPED((struct regexp *)SvANY(prog))
-#define RX_WRAPLEN(prog) RXp_WRAPLEN((struct regexp *)SvANY(prog))
+#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)
+/* 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_WRAPLEN(prog) SvCUR(prog)
#define RX_CHECK_SUBSTR(prog) (((struct regexp *)SvANY(prog))->check_substr)
-#define RX_EXTFLAGS(prog) RXp_EXTFLAGS((struct regexp *)SvANY(prog))
#define RX_REFCNT(prog) SvREFCNT(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)
+#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_SUBOFFSET(prog) \
+ (*({ \
+ const REGEXP *const _rx_suboffset = (prog); \
+ assert(SvTYPE(_rx_suboffset) == SVt_REGEXP); \
+ &SvANY(_rx_suboffset)->suboffset; \
+ }))
+# define RX_SUBCOFFSET(prog) \
+ (*({ \
+ const REGEXP *const _rx_subcoffset = (prog); \
+ assert(SvTYPE(_rx_subcoffset) == SVt_REGEXP); \
+ &SvANY(_rx_subcoffset)->subcoffset; \
+ }))
+# 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_SUBOFFSET(prog) (((struct regexp *)SvANY(prog))->suboffset)
+# define RX_SUBCOFFSET(prog) (((struct regexp *)SvANY(prog))->subcoffset)
+# 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_SUBBEG(prog) (((struct regexp *)SvANY(prog))->subbeg)
#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)
#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
#define RX_MATCH_COPY_FREE(rx) \
- STMT_START {if (rx->saved_copy) { \
- SV_CHECK_THINKFIRST_COW_DROP(rx->saved_copy); \
+ STMT_START {if (RX_SAVED_COPY(rx)) { \
+ SV_CHECK_THINKFIRST_COW_DROP(RX_SAVED_COPY(rx)); \
} \
if (RX_MATCH_COPIED(rx)) { \
Safefree(RX_SUBBEG(rx)); \
#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)))
-
+
+/* Whether the pattern stored at RX_WRAPPED is in UTF-8 */
+#define RX_UTF8(prog) SvUTF8(prog)
+
#define REXEC_COPY_STR 0x01 /* Need to copy the string. */
#define REXEC_CHECKED 0x02 /* check_substr already checked. */
#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(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC)
+#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
# define ReREFCNT_inc(re) \
({ \
/* This is here to generate a casting warning if incorrect. */ \
- REGEXP *const zwapp = (re); \
- SvREFCNT_inc(zwapp); \
+ REGEXP *const _rerefcnt_inc = (re); \
+ assert(SvTYPE(_rerefcnt_inc) == SVt_REGEXP); \
+ SvREFCNT_inc(_rerefcnt_inc); \
+ _rerefcnt_inc; \
})
# define ReREFCNT_dec(re) \
({ \
/* This is here to generate a casting warning if incorrect. */ \
- REGEXP *const boff = (re); \
- SvREFCNT_dec(boff); \
+ REGEXP *const _rerefcnt_dec = (re); \
+ SvREFCNT_dec(_rerefcnt_dec); \
})
#else
# define ReREFCNT_dec(re) SvREFCNT_dec(re)
-# define ReREFCNT_inc(re) SvREFCNT_inc(re)
+# define ReREFCNT_inc(re) ((REGEXP *) SvREFCNT_inc(re))
#endif
/* FIXME for plugins. */
#define FBMrf_MULTILINE 1
-/* an accepting state/position*/
-struct _reg_trie_accepted {
- U8 *endpos;
- U16 wordnum;
-};
-typedef struct _reg_trie_accepted reg_trie_accepted;
-
/* some basic information about the current match that is created by
* Perl_regexec_flags and then passed to regtry(), regmatch() etc */
/* this first element must match u.yes */
struct regmatch_state *prev_yes_state;
U32 lastparen;
+ U32 lastcloseparen;
CHECKPOINT cp;
} branchlike;
/* 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 */
/* the first elements must match u.branchlike */
struct regmatch_state *prev_yes_state;
U32 lastparen;
+ U32 lastcloseparen;
CHECKPOINT cp;
- reg_trie_accepted *accept_buff; /* accepting states we have seen */
- U32 accepted; /* how many accepting states we have seen */
+ 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 */
} trie;
/* special types - these members are used to store state for special
/* this first element must match u.yes */
struct regmatch_state *prev_yes_state;
struct regmatch_state *prev_curlyx; /* previous cur_curlyx */
- regnode *A, *B; /* the nodes corresponding to /A*B/ */
+ regnode *me; /* the CURLYX node */
+ regnode *B; /* the B node in /A*B/ */
CHECKPOINT cp; /* remember current savestack index */
bool minmod;
int parenfloor;/* how far back to strip paren data */
- int min; /* the minimal number of A's to match */
- int max; /* the maximal number of A's to match */
/* these two are modified by WHILEM */
int count; /* how many instances of A we've matched */
struct regmatch_state *prev_yes_state;
I32 c1, c2; /* case fold search */
CHECKPOINT cp;
+ U32 lastparen;
+ U32 lastcloseparen;
I32 alen; /* length of first-matched A string */
I32 count;
bool minmod;
struct {
U32 paren;
CHECKPOINT cp;
+ U32 lastparen;
+ U32 lastcloseparen;
I32 c1, c2; /* case fold search */
char *maxpos; /* highest possible point in string to match */
char *oldloc; /* the previous locinput */
#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_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_oldsavedoffset PL_reg_state.re_state_reg_oldsavedoffset
+#define PL_reg_oldsavedcoffset PL_reg_state.re_state_reg_oldsavedcoffset
#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
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_eval_setup_done; /* from regexec.c */
bool re_state_reg_match_utf8; /* from regexec.c */
+ bool re_reparsing; /* runtime (?{}) fed back into parser */
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_oldsavedoffset; /* old offset of saved substr during match */
+ STRLEN re_state_reg_oldsavedcoffset;/* old coffset 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 */
* 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:
*/
https://perl5.git.perl.org / perl5.git / blobdiff