/* regcomp.h
+ *
+ * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+ * 2000, 2001, 2002, 2003, 2005, 2006, 2007, 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.
+ *
*/
+#include "regcharclass.h"
typedef OP OP_4tree; /* Will be redefined later. */
+
+/* Convert branch sequences to more efficient trie ops? */
+#define PERL_ENABLE_TRIE_OPTIMISATION 1
+
+/* Be really agressive about optimising patterns with trie sequences? */
+#define PERL_ENABLE_EXTENDED_TRIE_OPTIMISATION 1
+
+/* Use old style unicode mappings for perl and posix character classes
+ *
+ * NOTE: Enabling this essentially breaks character class matching against unicode
+ * strings, so that POSIX char classes match when they shouldn't, and \d matches
+ * way more than 10 characters, and sometimes a charclass and its complement either
+ * both match or neither match.
+ * NOTE: Disabling this will cause various backwards compatibility issues to rear
+ * their head, and tests to fail. However it will make the charclass behaviour
+ * consistant regardless of internal string type, and make character class inversions
+ * consistant. The tests that fail in the regex engine are basically broken tests.
+ *
+ * Personally I think 5.12 should disable this for sure. Its a bit more debatable for
+ * 5.10, so for now im leaving it enabled.
+ * XXX: It is now enabled for 5.11/5.12
+ *
+ * -demerphq
+ */
+#define PERL_LEGACY_UNICODE_CHARCLASS_MAPPINGS 1
+
+/* Should the optimiser take positive assertions into account? */
+#define PERL_ENABLE_POSITIVE_ASSERTION_STUDY 0
+
+/* Not for production use: */
+#define PERL_ENABLE_EXPERIMENTAL_REGEX_OPTIMISATIONS 0
+
+/* Activate offsets code - set to if 1 to enable */
+#ifdef DEBUGGING
+#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
* simple cases. They are:
*
- * regstart sv that must begin a match; Nullch if none obvious
+ * regstart sv that must begin a match; NULL if none obvious
* reganch is the match anchored (at beginning-of-line only)?
* regmust string (pointer into program) that match must include, or NULL
* [regmust changed to SV* for bminstr()--law]
* For instance, /[a-z].foo/ has a regmust of 'foo' and a regback of 2.]
*/
-/* #ifndef gould */
-/* #ifndef cray */
-/* #ifndef eta10 */
-#define REGALIGN
-/* #endif */
-/* #endif */
-/* #endif */
-
-#ifdef REGALIGN
-# define REGALIGN_STRUCT
-#endif
-
/*
* Structure for regexp "program". This is essentially a linear encoding
* of a nondeterministic finite-state machine (aka syntax charts or
* a literal string; for others, it is a node leading into a sub-FSM. In
* particular, the operand of a BRANCH node is the first node of the branch.
* (NB this is *not* a tree structure: the tail of the branch connects
- * to the thing following the set of BRANCHes.) The opcodes are:
+ * to the thing following the set of BRANCHes.) The opcodes are defined
+ * in regnodes.h which is generated from regcomp.sym by regcomp.pl.
*/
-/* definition number opnd? meaning */
-#define END 0 /* no End of program. */
-#define BOL 1 /* no Match "" at beginning of line. */
-#define MBOL 2 /* no Same, assuming multiline. */
-#define SBOL 3 /* no Same, assuming singleline. */
-#define EOL 4 /* no Match "" at end of line. */
-#define MEOL 5 /* no Same, assuming multiline. */
-#define SEOL 6 /* no Same, assuming singleline. */
-#define ANY 7 /* no Match any one character (except newline). */
-#define SANY 8 /* no Match any one character. */
-#define ANYOF 9 /* sv Match character in (or not in) this class. */
-#define CURLY 10 /* sv Match this simple thing {n,m} times. */
-#define CURLYX 11 /* sv Match this complex thing {n,m} times. */
-#define BRANCH 12 /* node Match this alternative, or the next... */
-#define BACK 13 /* no Match "", "next" ptr points backward. */
-#define EXACT 14 /* sv Match this string (preceded by length). */
-#define EXACTF 15 /* sv Match this string, folded (prec. by length). */
-#define EXACTFL 16 /* sv Match this string, folded in locale (w/len). */
-#define NOTHING 17 /* no Match empty string. */
-#define STAR 18 /* node Match this (simple) thing 0 or more times. */
-#define PLUS 19 /* node Match this (simple) thing 1 or more times. */
-#define BOUND 20 /* no Match "" at any word boundary */
-#define BOUNDL 21 /* no Match "" at any word boundary */
-#define NBOUND 22 /* no Match "" at any word non-boundary */
-#define NBOUNDL 23 /* no Match "" at any word non-boundary */
-#define REF 24 /* num Match some already matched string */
-#define OPEN 25 /* num Mark this point in input as start of #n. */
-#define CLOSE 26 /* num Analogous to OPEN. */
-#define MINMOD 27 /* no Next operator is not greedy. */
-#define GPOS 28 /* no Matches where last m//g left off. */
-#define IFMATCH 29 /* off Succeeds if the following matches. */
-#define UNLESSM 30 /* off Fails if the following matches. */
-#define SUCCEED 31 /* no Return from a subroutine, basically. */
-#define WHILEM 32 /* no Do curly processing and see if rest matches. */
-#define ALNUM 33 /* no Match any alphanumeric character */
-#define ALNUML 34 /* no Match any alphanumeric char in locale */
-#define NALNUM 35 /* no Match any non-alphanumeric character */
-#define NALNUML 36 /* no Match any non-alphanumeric char in locale */
-#define SPACE 37 /* no Match any whitespace character */
-#define SPACEL 38 /* no Match any whitespace char in locale */
-#define NSPACE 39 /* no Match any non-whitespace character */
-#define NSPACEL 40 /* no Match any non-whitespace char in locale */
-#define DIGIT 41 /* no Match any numeric character */
-#define NDIGIT 42 /* no Match any non-numeric character */
-#define CURLYM 43 /* no Match this medium-complex thing {n,m} times. */
-#define CURLYN 44 /* no Match next-after-this simple thing
- {n,m} times, set parenths. */
-#define TAIL 45 /* no Match empty string. Can jump here from outside. */
-#define REFF 46 /* num Match already matched string, folded */
-#define REFFL 47 /* num Match already matched string, folded in loc. */
-#define EVAL 48 /* evl Execute some Perl code. */
-#define LONGJMP 49 /* off Jump far away, requires REGALIGN_STRUCT. */
-#define BRANCHJ 50 /* off BRANCH with long offset, requires REGALIGN_STRUCT. */
-#define IFTHEN 51 /* off Switch, should be preceeded by switcher . */
-#define GROUPP 52 /* num Whether the group matched. */
-#define LOGICAL 53 /* no Next opcode should set the flag only. */
-#define SUSPEND 54 /* off "Independent" sub-RE. */
-#define RENUM 55 /* off Group with independently numbered parens. */
-#define OPTIMIZED 56 /* off Placeholder for dump. */
-
-/*
- * Opcode notes:
- *
- * BRANCH The set of branches constituting a single choice are hooked
- * together with their "next" pointers, since precedence prevents
- * anything being concatenated to any individual branch. The
- * "next" pointer of the last BRANCH in a choice points to the
- * thing following the whole choice. This is also where the
- * final "next" pointer of each individual branch points; each
- * branch starts with the operand node of a BRANCH node.
- *
- * BACK Normal "next" pointers all implicitly point forward; BACK
- * exists to make loop structures possible.
- *
- * STAR,PLUS '?', and complex '*' and '+', are implemented as circular
- * BRANCH structures using BACK. Simple cases (one character
- * per match) are implemented with STAR and PLUS for speed
- * and to minimize recursive plunges.
- *
- * OPEN,CLOSE,GROUPP ...are numbered at compile time.
- */
-
-#ifndef DOINIT
-EXTCONST U8 regkind[];
-#else
-EXTCONST U8 regkind[] = {
- END,
- BOL,
- BOL,
- BOL,
- EOL,
- EOL,
- EOL,
- ANY,
- ANY,
- ANYOF,
- CURLY,
- CURLY,
- BRANCH,
- BACK,
- EXACT,
- EXACT,
- EXACT,
- NOTHING,
- STAR,
- PLUS,
- BOUND,
- BOUND,
- NBOUND,
- NBOUND,
- REF,
- OPEN,
- CLOSE,
- MINMOD,
- GPOS,
- BRANCHJ,
- BRANCHJ,
- END,
- WHILEM,
- ALNUM,
- ALNUM,
- NALNUM,
- NALNUM,
- SPACE,
- SPACE,
- NSPACE,
- NSPACE,
- DIGIT,
- NDIGIT,
- CURLY,
- CURLY,
- NOTHING,
- REF,
- REF,
- EVAL,
- LONGJMP,
- BRANCHJ,
- BRANCHJ,
- GROUPP,
- LOGICAL,
- BRANCHJ,
- BRANCHJ,
- NOTHING,
-};
-#endif
-
-/* The following have no fixed length. char* since we do strchr on it. */
-#ifndef DOINIT
-EXTCONST char varies[];
-#else
-EXTCONST char varies[] = {
- BRANCH, BACK, STAR, PLUS, CURLY, CURLYX, REF, REFF, REFFL,
- WHILEM, CURLYM, CURLYN, BRANCHJ, IFTHEN, SUSPEND, 0
-};
-#endif
-
-/* The following always have a length of 1. char* since we do strchr on it. */
-#ifndef DOINIT
-EXTCONST char simple[];
-#else
-EXTCONST char simple[] = {
- ANY, SANY, ANYOF,
- ALNUM, ALNUML, NALNUM, NALNUML,
- SPACE, SPACEL, NSPACE, NSPACEL,
- DIGIT, NDIGIT, 0
-};
-#endif
-
/*
* A node is one char of opcode followed by two chars of "next" pointer.
* "Next" pointers are stored as two 8-bit pieces, high order first. The
* Using two bytes for the "next" pointer is vast overkill for most things,
* but allows patterns to get big without disasters.
*
- * [If REGALIGN is defined, the "next" pointer is always aligned on an even
+ * [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.]
*/
-#ifdef REGALIGN_STRUCT
+/* This is the stuff that used to live in regexp.h that was truly
+ private to the engine itself. It now lives here. */
+
+
+
+ typedef struct regexp_internal {
+ int name_list_idx; /* Optional data index of an array of paren names */
+ union {
+ U32 *offsets; /* offset annotations 20001228 MJD
+ data about mapping the program to the
+ string -
+ offsets[0] is proglen when this is used
+ */
+ U32 proglen;
+ } u;
+
+ regnode *regstclass; /* Optional startclass as identified or constructed
+ by the optimiser */
+ struct reg_data *data; /* Additional miscellaneous data used by the program.
+ Used to make it easier to clone and free arbitrary
+ data that the regops need. Often the ARG field of
+ a regop is an index into this structure */
+ regnode program[1]; /* Unwarranted chumminess with compiler. */
+} regexp_internal;
+
+#define RXi_SET(x,y) (x)->pprivate = (void*)(y)
+#define RXi_GET(x) ((regexp_internal *)((x)->pprivate))
+#define RXi_GET_DECL(r,ri) regexp_internal *ri = RXi_GET(r)
+/*
+ * Flags stored in regexp->intflags
+ * These are used only internally to the regexp engine
+ *
+ * See regexp.h for flags used externally to the regexp engine
+ */
+#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
+
+
+/* this is where the old regcomp.h started */
struct regnode_string {
- U8 flags;
+ U8 str_len;
U8 type;
U16 next_off;
- U8 string[1];
+ char string[1];
};
+/* Argument bearing node - workhorse,
+ arg1 is often for the data field */
struct regnode_1 {
U8 flags;
U8 type;
U32 arg1;
};
+/* Similar to a regnode_1 but with an extra signed argument */
+struct regnode_2L {
+ U8 flags;
+ U8 type;
+ U16 next_off;
+ U32 arg1;
+ I32 arg2;
+};
+
+/* 'Two field' -- Two 16 bit unsigned args */
struct regnode_2 {
U8 flags;
U8 type;
U16 arg2;
};
-#endif
-/* I16_MAX is no good for REG_INFTY because sizeof(short) > 2
- * is perfectly fine. In Cray C90 sizeof(short) == 4,
- * in Cray T90 sizeof(short) == 8. */
-#define REG_INFTY ((1<<15)-1)
+#define ANYOF_BITMAP_SIZE 32 /* 256 b/(8 b/B) */
+#define ANYOF_CLASSBITMAP_SIZE 4 /* up to 32 (8*4) named classes */
-#ifdef REGALIGN
-# define ARG_VALUE(arg) (arg)
-# define ARG__SET(arg,val) ((arg) = (val))
-#else
-# define ARG_VALUE(arg) (((*((char*)&arg)&0377)<<8) + (*(((char*)&arg)+1)&0377))
-# define ARG__SET(arg,val) (((char*)&arg)[0] = (val) >> 8; ((char*)&arg)[1] = (val) & 0377;)
+/* also used by trie */
+struct regnode_charclass {
+ U8 flags;
+ U8 type;
+ U16 next_off;
+ U32 arg1;
+ char bitmap[ANYOF_BITMAP_SIZE]; /* only compile-time */
+};
+
+struct regnode_charclass_class { /* has [[:blah:]] classes */
+ U8 flags; /* should have ANYOF_CLASS here */
+ U8 type;
+ U16 next_off;
+ U32 arg1;
+ char bitmap[ANYOF_BITMAP_SIZE]; /* both compile-time */
+ char classflags[ANYOF_CLASSBITMAP_SIZE]; /* and run-time */
+};
+
+/* XXX fix this description.
+ Impose a limit of REG_INFTY on various pattern matching operations
+ to limit stack growth and to avoid "infinite" recursions.
+*/
+/* The default size for REG_INFTY is I16_MAX, which is the same as
+ SHORT_MAX (see perl.h). Unfortunately I16 isn't necessarily 16 bits
+ (see handy.h). On the Cray C90, sizeof(short)==4 and hence I16_MAX is
+ ((1<<31)-1), while on the Cray T90, sizeof(short)==8 and I16_MAX is
+ ((1<<63)-1). To limit stack growth to reasonable sizes, supply a
+ smaller default.
+ --Andy Dougherty 11 June 1998
+*/
+#if SHORTSIZE > 2
+# ifndef REG_INFTY
+# define REG_INFTY ((1<<15)-1)
+# endif
+#endif
+
+#ifndef REG_INFTY
+# define REG_INFTY I16_MAX
#endif
+#define ARG_VALUE(arg) (arg)
+#define ARG__SET(arg,val) ((arg) = (val))
+
+#undef ARG
+#undef ARG1
+#undef ARG2
+
#define ARG(p) ARG_VALUE(ARG_LOC(p))
#define ARG1(p) ARG_VALUE(ARG1_LOC(p))
#define ARG2(p) ARG_VALUE(ARG2_LOC(p))
+#define ARG2L(p) ARG_VALUE(ARG2L_LOC(p))
+
#define ARG_SET(p, val) ARG__SET(ARG_LOC(p), (val))
#define ARG1_SET(p, val) ARG__SET(ARG1_LOC(p), (val))
#define ARG2_SET(p, val) ARG__SET(ARG2_LOC(p), (val))
+#define ARG2L_SET(p, val) ARG__SET(ARG2L_LOC(p), (val))
-#ifndef lint
-# ifdef REGALIGN
-# ifdef REGALIGN_STRUCT
-# define NEXT_OFF(p) ((p)->next_off)
-# define NODE_ALIGN(node)
-# define NODE_ALIGN_FILL(node) ((node)->flags = 0xde) /* deadbeef */
-# else
-# define NEXT_OFF(p) (*(short*)(p+1))
-# define NODE_ALIGN(node) ((!((long)node & 1)) ? node++ : 0)
-# define NODE_ALIGN_FILL(node) ((!((long)node & 1)) ? *node++ = 127 : 0)
-# endif
-# else
-# define NEXT_OFF(p) (((*((p)+1)&0377)<<8) + (*((p)+2)&0377))
-# define NODE_ALIGN(node)
-# define NODE_ALIGN_FILL(node)
-# endif
-#else /* lint */
-# define NEXT_OFF(p) 0
-# define NODE_ALIGN(node)
-# define NODE_ALIGN_FILL(node)
-#endif /* lint */
+#undef NEXT_OFF
+#undef NODE_ALIGN
+
+#define NEXT_OFF(p) ((p)->next_off)
+#define NODE_ALIGN(node)
+#define NODE_ALIGN_FILL(node) ((node)->flags = 0xde) /* deadbeef */
#define SIZE_ALIGN NODE_ALIGN
-#ifdef REGALIGN_STRUCT
-# define OP(p) ((p)->type)
-# define OPERAND(p) (((struct regnode_string *)p)->string)
-# define NODE_ALIGN(node)
-# define ARG_LOC(p) (((struct regnode_1 *)p)->arg1)
-# define ARG1_LOC(p) (((struct regnode_2 *)p)->arg1)
-# define ARG2_LOC(p) (((struct regnode_2 *)p)->arg2)
-# define NODE_STEP_REGNODE 1 /* sizeof(regnode)/sizeof(regnode) */
-# define EXTRA_STEP_2ARGS EXTRA_SIZE(struct regnode_2)
-#else
-# define OP(p) (*(p))
-# define OPERAND(p) ((p) + 3)
-# define ARG_LOC(p) (*(unsigned short*)(p+3))
-# define ARG1_LOC(p) (*(unsigned short*)(p+3))
-# define ARG2_LOC(p) (*(unsigned short*)(p+5))
-typedef char* regnode;
-# define NODE_STEP_REGNODE NODE_STEP_B
-# define EXTRA_STEP_2ARGS 4
-#endif
-
-#ifdef REGALIGN
-# define NODE_STEP_B 4
-#else
-# define NODE_STEP_B 3
-#endif
+#undef OP
+#undef OPERAND
+#undef MASK
+#undef STRING
+
+#define OP(p) ((p)->type)
+#define OPERAND(p) (((struct regnode_string *)p)->string)
+#define MASK(p) ((char*)OPERAND(p))
+#define STR_LEN(p) (((struct regnode_string *)p)->str_len)
+#define STRING(p) (((struct regnode_string *)p)->string)
+#define STR_SZ(l) ((l + sizeof(regnode) - 1) / sizeof(regnode))
+#define NODE_SZ_STR(p) (STR_SZ(STR_LEN(p))+1)
+
+#undef NODE_ALIGN
+#undef ARG_LOC
+#undef NEXTOPER
+#undef PREVOPER
+
+#define NODE_ALIGN(node)
+#define ARG_LOC(p) (((struct regnode_1 *)p)->arg1)
+#define ARG1_LOC(p) (((struct regnode_2 *)p)->arg1)
+#define ARG2_LOC(p) (((struct regnode_2 *)p)->arg2)
+#define ARG2L_LOC(p) (((struct regnode_2L *)p)->arg2)
+
+#define NODE_STEP_REGNODE 1 /* sizeof(regnode)/sizeof(regnode) */
+#define EXTRA_STEP_2ARGS EXTRA_SIZE(struct regnode_2)
+
+#define NODE_STEP_B 4
#define NEXTOPER(p) ((p) + NODE_STEP_REGNODE)
#define PREVOPER(p) ((p) - NODE_STEP_REGNODE)
-#ifdef REGALIGN_STRUCT
-# define FILL_ADVANCE_NODE(ptr, op) STMT_START { \
+#define FILL_ADVANCE_NODE(ptr, op) STMT_START { \
(ptr)->type = op; (ptr)->next_off = 0; (ptr)++; } STMT_END
-# define FILL_ADVANCE_NODE_ARG(ptr, op, arg) STMT_START { \
+#define FILL_ADVANCE_NODE_ARG(ptr, op, arg) STMT_START { \
ARG_SET(ptr, arg); FILL_ADVANCE_NODE(ptr, op); (ptr) += 1; } STMT_END
-#else
-# define FILL_ADVANCE_NODE(ptr, op) STMT_START { \
- *(ptr)++ = op; *(ptr)++ = '\0'; *(ptr)++ = '\0'; } STMT_END
-# define FILL_ADVANCE_NODE_ARG(ptr, op, arg) STMT_START { \
- ARG_SET(ptr, arg); FILL_ADVANCE_NODE(ptr, op); (ptr) += 2; } STMT_END
-#endif
-#define MAGIC 0234
+#define REG_MAGIC 0234
+
+#define SIZE_ONLY (RExC_emit == &PL_regdummy)
+
+/* Flags for node->flags of ANYOF */
+
+#define ANYOF_CLASS 0x08 /* has [[:blah:]] classes */
+#define ANYOF_INVERT 0x04
+#define ANYOF_FOLD 0x02
+#define ANYOF_LOCALE 0x01
+
+/* Used for regstclass only */
+#define ANYOF_EOS 0x10 /* Can match an empty string too */
+
+/* There is a character or a range past 0xff */
+#define ANYOF_UNICODE 0x20
+#define ANYOF_UNICODE_ALL 0x40 /* Can match any char past 0xff */
+
+/* size of node is large (includes class pointer) */
+#define ANYOF_LARGE 0x80
+
+/* Are there any runtime flags on in this node? */
+#define ANYOF_RUNTIME(s) (ANYOF_FLAGS(s) & 0x0f)
+
+#define ANYOF_FLAGS_ALL 0xff
+
+/* Character classes for node->classflags of ANYOF */
+/* Should be synchronized with a table in regprop() */
+/* 2n should pair with 2n+1 */
+
+#define ANYOF_ALNUM 0 /* \w, PL_utf8_alnum, utf8::IsWord, ALNUM */
+#define ANYOF_NALNUM 1
+#define ANYOF_SPACE 2 /* \s */
+#define ANYOF_NSPACE 3
+#define ANYOF_DIGIT 4 /* \d */
+#define ANYOF_NDIGIT 5
+#define ANYOF_ALNUMC 6 /* [[:alnum:]] isalnum(3), utf8::IsAlnum, ALNUMC */
+#define ANYOF_NALNUMC 7
+#define ANYOF_ALPHA 8
+#define ANYOF_NALPHA 9
+#define ANYOF_ASCII 10
+#define ANYOF_NASCII 11
+#define ANYOF_CNTRL 12
+#define ANYOF_NCNTRL 13
+#define ANYOF_GRAPH 14
+#define ANYOF_NGRAPH 15
+#define ANYOF_LOWER 16
+#define ANYOF_NLOWER 17
+#define ANYOF_PRINT 18
+#define ANYOF_NPRINT 19
+#define ANYOF_PUNCT 20
+#define ANYOF_NPUNCT 21
+#define ANYOF_UPPER 22
+#define ANYOF_NUPPER 23
+#define ANYOF_XDIGIT 24
+#define ANYOF_NXDIGIT 25
+#define ANYOF_PSXSPC 26 /* POSIX space: \s plus the vertical tab */
+#define ANYOF_NPSXSPC 27
+#define ANYOF_BLANK 28 /* GNU extension: space and tab: non-vertical space */
+#define ANYOF_NBLANK 29
+
+#define ANYOF_MAX 32
+
+/* pseudo classes, not stored in the class bitmap, but used as flags
+ during compilation of char classes */
+
+#define ANYOF_VERTWS (ANYOF_MAX+1)
+#define ANYOF_NVERTWS (ANYOF_MAX+2)
+#define ANYOF_HORIZWS (ANYOF_MAX+3)
+#define ANYOF_NHORIZWS (ANYOF_MAX+4)
+
+/* Backward source code compatibility. */
+
+#define ANYOF_ALNUML ANYOF_ALNUM
+#define ANYOF_NALNUML ANYOF_NALNUM
+#define ANYOF_SPACEL ANYOF_SPACE
+#define ANYOF_NSPACEL ANYOF_NSPACE
+
+/* 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_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_CLASS_ZERO(ret) Zero(((struct regnode_charclass_class*)(ret))->classflags, ANYOF_CLASSBITMAP_SIZE, char)
+#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_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) \
+ 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))
+#define ANYOF_CLASS_ADD_SKIP (ANYOF_CLASS_SKIP - ANYOF_SKIP)
-#define SIZE_ONLY (regcode == ®dummy)
-
-/* Flags for first parameter byte of ANYOF */
-#define ANYOF_INVERT 0x40
-#define ANYOF_FOLD 0x20
-#define ANYOF_LOCALE 0x10
-#define ANYOF_ISA 0x0F
-#define ANYOF_ALNUML 0x08
-#define ANYOF_NALNUML 0x04
-#define ANYOF_SPACEL 0x02
-#define ANYOF_NSPACEL 0x01
-
-#ifdef REGALIGN_STRUCT
-#define ANY_SKIP ((33 - 1)/sizeof(regnode) + 1)
-#else
-#define ANY_SKIP 32 /* overwrite the first byte of
- * the next guy. */
-#endif
/*
* Utility definitions.
*/
-#ifndef lint
#ifndef CHARMASK
-#define UCHARAT(p) ((int)*(unsigned char *)(p))
+# define UCHARAT(p) ((int)*(const U8*)(p))
#else
-#define UCHARAT(p) ((int)*(p)&CHARMASK)
+# define UCHARAT(p) ((int)*(p)&CHARMASK)
#endif
-#else /* lint */
-#define UCHARAT(p) regdummy
-#endif /* lint */
-
-#define FAIL(m) croak ("/%.127s/: %s", regprecomp,m)
-#define FAIL2(pat,m) re_croak2("/%.127s/: ",pat,regprecomp,m)
#define EXTRA_SIZE(guy) ((sizeof(guy)-1)/sizeof(struct regnode))
-#ifdef REG_COMP_C
-const static U8 regarglen[] = {
-# ifdef REGALIGN_STRUCT
- 0,0,0,0,0,0,0,0,0,0,
- /*CURLY*/ EXTRA_SIZE(struct regnode_2),
- /*CURLYX*/ EXTRA_SIZE(struct regnode_2),
- 0,0,0,0,0,0,0,0,0,0,0,0,
- /*REF*/ EXTRA_SIZE(struct regnode_1),
- /*OPEN*/ EXTRA_SIZE(struct regnode_1),
- /*CLOSE*/ EXTRA_SIZE(struct regnode_1),
- 0,0,
- /*IFMATCH*/ EXTRA_SIZE(struct regnode_1),
- /*UNLESSM*/ EXTRA_SIZE(struct regnode_1),
- 0,0,0,0,0,0,0,0,0,0,0,0,
- /*CURLYM*/ EXTRA_SIZE(struct regnode_2),
- /*CURLYN*/ EXTRA_SIZE(struct regnode_2),
- 0,
- /*REFF*/ EXTRA_SIZE(struct regnode_1),
- /*REFFL*/ EXTRA_SIZE(struct regnode_1),
- /*EVAL*/ EXTRA_SIZE(struct regnode_1),
- /*LONGJMP*/ EXTRA_SIZE(struct regnode_1),
- /*BRANCHJ*/ EXTRA_SIZE(struct regnode_1),
- /*IFTHEN*/ EXTRA_SIZE(struct regnode_1),
- /*GROUPP*/ EXTRA_SIZE(struct regnode_1),
- /*LOGICAL*/ 0,
- /*SUSPEND*/ EXTRA_SIZE(struct regnode_1),
- /*RENUM*/ EXTRA_SIZE(struct regnode_1), 0,
-# else
- 0,0,0,0,0,0,0,0,0,0,
- /*CURLY*/ 4, /*CURLYX*/ 4,
- 0,0,0,0,0,0,0,0,0,0,0,0,
- /*REF*/ 2, /*OPEN*/ 2, /*CLOSE*/ 2,
- 0,0, /*IFMATCH*/ 2, /*UNLESSM*/ 2,
- 0,0,0,0,0,0,0,0,0,0,0,0,/*CURLYM*/ 4,/*CURLYN*/ 4,
- 0, /*REFF*/ 2, /*REFFL*/ 2, /*EVAL*/ 2, /*LONGJMP*/ 2, /*BRANCHJ*/ 2,
- /*IFTHEN*/ 2, /*GROUPP*/ 2, /*LOGICAL*/ 0, /*RENUM*/ 2, /*RENUM*/ 2, 0,
-# endif
+#define REG_SEEN_ZERO_LEN 0x00000001
+#define REG_SEEN_LOOKBEHIND 0x00000002
+#define REG_SEEN_GPOS 0x00000004
+#define REG_SEEN_EVAL 0x00000008
+#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
+
+START_EXTERN_C
+
+#ifdef PLUGGABLE_RE_EXTENSION
+#include "re_nodes.h"
+#else
+#include "regnodes.h"
+#endif
+
+#ifndef PLUGGABLE_RE_EXTENSION
+#ifndef DOINIT
+EXTCONST regexp_engine PL_core_reg_engine;
+#else /* DOINIT */
+EXTCONST regexp_engine PL_core_reg_engine = {
+ Perl_re_compile,
+ Perl_regexec_flags,
+ Perl_re_intuit_start,
+ Perl_re_intuit_string,
+ Perl_regfree_internal,
+ Perl_reg_numbered_buff_fetch,
+ Perl_reg_numbered_buff_store,
+ Perl_reg_numbered_buff_length,
+ Perl_reg_named_buff,
+ Perl_reg_named_buff_iter,
+ Perl_reg_qr_package,
+#if defined(USE_ITHREADS)
+ Perl_regdupe_internal
+#endif
+};
+#endif /* DOINIT */
+#endif /* PLUGGABLE_RE_EXTENSION */
+
+
+END_EXTERN_C
+
+
+/* .what is a character array with one character for each member of .data
+ * The character describes the function of the corresponding .data item:
+ * f - start-class data for regstclass optimization
+ * n - Root of op tree for (?{EVAL}) item
+ * o - Start op for (?{EVAL}) item
+ * p - Pad for (?{EVAL}) item
+ * s - swash for Unicode-style character class, and the multicharacter
+ * strings resulting from casefolding the single-character entries
+ * in the character class
+ * t - trie struct
+ * u - trie struct's widecharmap (a HV, so can't share, must dup)
+ * also used for revcharmap and words under DEBUGGING
+ * T - aho-trie struct
+ * S - sv for named capture lookup
+ * 20010712 mjd@plover.com
+ * (Remember to update re_dup() and pregfree() if you add any items.)
+ */
+struct reg_data {
+ U32 count;
+ U8 *what;
+ void* data[1];
+};
+
+/* Code in S_to_utf8_substr() and S_to_byte_substr() in regexec.c accesses
+ anchored* and float* via array indexes 0 and 1. */
+#define anchored_substr substrs->data[0].substr
+#define anchored_utf8 substrs->data[0].utf8_substr
+#define anchored_offset substrs->data[0].min_offset
+#define anchored_end_shift substrs->data[0].end_shift
+
+#define float_substr substrs->data[1].substr
+#define float_utf8 substrs->data[1].utf8_substr
+#define float_min_offset substrs->data[1].min_offset
+#define float_max_offset substrs->data[1].max_offset
+#define float_end_shift substrs->data[1].end_shift
+
+#define check_substr substrs->data[2].substr
+#define check_utf8 substrs->data[2].utf8_substr
+#define check_offset_min substrs->data[2].min_offset
+#define check_offset_max substrs->data[2].max_offset
+#define check_end_shift substrs->data[2].end_shift
+
+#define RX_ANCHORED_SUBSTR(rx) (((struct regexp *)SvANY(rx))->anchored_substr)
+#define RX_ANCHORED_UTF8(rx) (((struct regexp *)SvANY(rx))->anchored_utf8)
+#define RX_FLOAT_SUBSTR(rx) (((struct regexp *)SvANY(rx))->float_substr)
+#define RX_FLOAT_UTF8(rx) (((struct regexp *)SvANY(rx))->float_utf8)
+
+/* trie related stuff */
+
+/* a transition record for the state machine. the
+ check field determines which state "owns" the
+ transition. the char the transition is for is
+ determined by offset from the owning states base
+ field. the next field determines which state
+ is to be transitioned to if any.
+*/
+struct _reg_trie_trans {
+ U32 next;
+ U32 check;
+};
+
+/* a transition list element for the list based representation */
+struct _reg_trie_trans_list_elem {
+ U16 forid;
+ U32 newstate;
+};
+typedef struct _reg_trie_trans_list_elem reg_trie_trans_le;
+
+/* a state for compressed nodes. base is an offset
+ into an array of reg_trie_trans array. If wordnum is
+ nonzero the state is accepting. if base is zero then
+ the state has no children (and will be accepting)
+*/
+struct _reg_trie_state {
+ U16 wordnum;
+ union {
+ U32 base;
+ reg_trie_trans_le* list;
+ } trans;
};
-const static char reg_off_by_arg[] = {
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0 .. 15 */
- 0,0,0,0,0,0,0,0,0,0,0,0,0, /*IFMATCH*/ 2, /*UNLESSM*/ 2, 0,
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 32 .. 47 */
- 0, /*LONGJMP*/ 1, /*BRANCHJ*/ 1, /*IFTHEN*/ 1, 0, 0,
- /*RENUM*/ 1, /*RENUM*/ 1,0,
+/* info per word; indexed by wordnum */
+typedef struct {
+ U16 prev; /* previous word in acceptance chain; eg in
+ * zzz|abc|ab/ after matching the chars abc, the
+ * accepted word is #2, and the previous accepted
+ * word is #3 */
+ U32 len; /* how many chars long is this word? */
+ U32 accept; /* accept state for this word */
+} reg_trie_wordinfo;
+
+
+typedef struct _reg_trie_state reg_trie_state;
+typedef struct _reg_trie_trans reg_trie_trans;
+
+
+/* anything in here that needs to be freed later
+ should be dealt with in pregfree.
+ refcount is first in both this and _reg_ac_data to allow a space
+ optimisation in Perl_regdupe. */
+struct _reg_trie_data {
+ U32 refcount; /* number of times this trie is referenced */
+ U32 lasttrans; /* last valid transition element */
+ U16 *charmap; /* byte to charid lookup array */
+ reg_trie_state *states; /* state data */
+ reg_trie_trans *trans; /* array of transition elements */
+ char *bitmap; /* stclass bitmap */
+ U16 *jump; /* optional 1 indexed array of offsets before tail
+ for the node following a given word. */
+ reg_trie_wordinfo *wordinfo; /* array of info per word */
+ U16 uniquecharcount; /* unique chars in trie (width of trans table) */
+ U32 startstate; /* initial state - used for common prefix optimisation */
+ STRLEN minlen; /* minimum length of words in trie - build/opt only? */
+ STRLEN maxlen; /* maximum length of words in trie - build/opt only? */
+ U32 prefixlen; /* #chars in common prefix */
+ U32 statecount; /* Build only - number of states in the states array
+ (including the unused zero state) */
+ U32 wordcount; /* Build only */
+#ifdef DEBUGGING
+ STRLEN charcount; /* Build only */
+#endif
};
+/* There is one (3 under DEBUGGING) pointers that logically belong in this
+ structure, but are held outside as they need duplication on thread cloning,
+ whereas the rest of the structure can be read only:
+ HV *widecharmap; code points > 255 to charid
+#ifdef DEBUGGING
+ AV *words; Array of words contained in trie, for dumping
+ AV *revcharmap; Map of each charid back to its character representation
#endif
+*/
+
+#define TRIE_WORDS_OFFSET 2
+
+typedef struct _reg_trie_data reg_trie_data;
+
+/* refcount is first in both this and _reg_trie_data to allow a space
+ optimisation in Perl_regdupe. */
+struct _reg_ac_data {
+ U32 refcount;
+ U32 trie;
+ U32 *fail;
+ reg_trie_state *states;
+};
+typedef struct _reg_ac_data reg_ac_data;
+
+/* ANY_BIT doesnt use the structure, so we can borrow it here.
+ This is simpler than refactoring all of it as wed end up with
+ three different sets... */
+
+#define TRIE_BITMAP(p) (((reg_trie_data *)(p))->bitmap)
+#define TRIE_BITMAP_BYTE(p, c) (TRIE_BITMAP(p)[(((U8)(c)) >> 3) & 31])
+#define TRIE_BITMAP_SET(p, c) (TRIE_BITMAP_BYTE(p, c) |= ANYOF_BIT((U8)c))
+#define TRIE_BITMAP_CLEAR(p,c) (TRIE_BITMAP_BYTE(p, c) &= ~ANYOF_BIT((U8)c))
+#define TRIE_BITMAP_TEST(p, c) (TRIE_BITMAP_BYTE(p, c) & ANYOF_BIT((U8)c))
+
+#define IS_ANYOF_TRIE(op) ((op)==TRIEC || (op)==AHOCORASICKC)
+#define IS_TRIE_AC(op) ((op)>=AHOCORASICK)
-#define REG_SEEN_ZERO_LEN 1
-#define REG_SEEN_LOOKBEHIND 2
-#define REG_SEEN_GPOS 4
+
+#define BITMAP_BYTE(p, c) (((U8*)p)[(((U8)(c)) >> 3) & 31])
+#define BITMAP_TEST(p, c) (BITMAP_BYTE(p, c) & ANYOF_BIT((U8)c))
+
+/* these defines assume uniquecharcount is the correct variable, and state may be evaluated twice */
+#define TRIE_NODENUM(state) (((state)-1)/(trie->uniquecharcount)+1)
+#define SAFE_TRIE_NODENUM(state) ((state) ? (((state)-1)/(trie->uniquecharcount)+1) : (state))
+#define TRIE_NODEIDX(state) ((state) ? (((state)-1)*(trie->uniquecharcount)+1) : (state))
#ifdef DEBUGGING
-EXT char *colors[4]; /* not dEXT since we do EXTERN/INTERN.h shuffle */
-#endif
+#define TRIE_CHARCOUNT(trie) ((trie)->charcount)
+#else
+#define TRIE_CHARCOUNT(trie) (trie_charcount)
+#endif
+
+#define RE_TRIE_MAXBUF_INIT 65536
+#define RE_TRIE_MAXBUF_NAME "\022E_TRIE_MAXBUF"
+#define RE_DEBUG_FLAGS "\022E_DEBUG_FLAGS"
+
+/*
+
+RE_DEBUG_FLAGS is used to control what debug output is emitted
+its divided into three groups of options, some of which interact.
+The three groups are: Compile, Execute, Extra. There is room for a
+further group, as currently only the low three bytes are used.
+
+ Compile Options:
+
+ PARSE
+ PEEP
+ TRIE
+ PROGRAM
+ OFFSETS
+
+ Execute Options:
+
+ INTUIT
+ MATCH
+ TRIE
+
+ Extra Options
+
+ TRIE
+ OFFSETS
+
+If you modify any of these make sure you make corresponding changes to
+re.pm, especially to the documentation.
+
+*/
+
+
+/* Compile */
+#define RE_DEBUG_COMPILE_MASK 0x0000FF
+#define RE_DEBUG_COMPILE_PARSE 0x000001
+#define RE_DEBUG_COMPILE_OPTIMISE 0x000002
+#define RE_DEBUG_COMPILE_TRIE 0x000004
+#define RE_DEBUG_COMPILE_DUMP 0x000008
+#define RE_DEBUG_COMPILE_FLAGS 0x000010
+
+/* Execute */
+#define RE_DEBUG_EXECUTE_MASK 0x00FF00
+#define RE_DEBUG_EXECUTE_INTUIT 0x000100
+#define RE_DEBUG_EXECUTE_MATCH 0x000200
+#define RE_DEBUG_EXECUTE_TRIE 0x000400
+
+/* Extra */
+#define RE_DEBUG_EXTRA_MASK 0xFF0000
+#define RE_DEBUG_EXTRA_TRIE 0x010000
+#define RE_DEBUG_EXTRA_OFFSETS 0x020000
+#define RE_DEBUG_EXTRA_OFFDEBUG 0x040000
+#define RE_DEBUG_EXTRA_STATE 0x080000
+#define RE_DEBUG_EXTRA_OPTIMISE 0x100000
+#define RE_DEBUG_EXTRA_BUFFERS 0x400000
+#define RE_DEBUG_EXTRA_GPOS 0x800000
+/* combined */
+#define RE_DEBUG_EXTRA_STACK 0x280000
+
+#define RE_DEBUG_FLAG(x) (re_debug_flags & x)
+/* Compile */
+#define DEBUG_COMPILE_r(x) DEBUG_r( \
+ if (re_debug_flags & RE_DEBUG_COMPILE_MASK) x )
+#define DEBUG_PARSE_r(x) DEBUG_r( \
+ if (re_debug_flags & RE_DEBUG_COMPILE_PARSE) x )
+#define DEBUG_OPTIMISE_r(x) DEBUG_r( \
+ if (re_debug_flags & RE_DEBUG_COMPILE_OPTIMISE) x )
+#define DEBUG_PARSE_r(x) DEBUG_r( \
+ if (re_debug_flags & RE_DEBUG_COMPILE_PARSE) x )
+#define DEBUG_DUMP_r(x) DEBUG_r( \
+ if (re_debug_flags & RE_DEBUG_COMPILE_DUMP) x )
+#define DEBUG_TRIE_COMPILE_r(x) DEBUG_r( \
+ 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 )
+/* Execute */
+#define DEBUG_EXECUTE_r(x) DEBUG_r( \
+ if (re_debug_flags & RE_DEBUG_EXECUTE_MASK) x )
+#define DEBUG_INTUIT_r(x) DEBUG_r( \
+ if (re_debug_flags & RE_DEBUG_EXECUTE_INTUIT) x )
+#define DEBUG_MATCH_r(x) DEBUG_r( \
+ if (re_debug_flags & RE_DEBUG_EXECUTE_MATCH) x )
+#define DEBUG_TRIE_EXECUTE_r(x) DEBUG_r( \
+ if (re_debug_flags & RE_DEBUG_EXECUTE_TRIE) x )
+
+/* Extra */
+#define DEBUG_EXTRA_r(x) DEBUG_r( \
+ if (re_debug_flags & RE_DEBUG_EXTRA_MASK) x )
+#define DEBUG_OFFSETS_r(x) DEBUG_r( \
+ if (re_debug_flags & RE_DEBUG_EXTRA_OFFSETS) x )
+#define DEBUG_STATE_r(x) DEBUG_r( \
+ if (re_debug_flags & RE_DEBUG_EXTRA_STATE) x )
+#define DEBUG_STACK_r(x) DEBUG_r( \
+ if (re_debug_flags & RE_DEBUG_EXTRA_STACK) x )
+#define DEBUG_BUFFERS_r(x) DEBUG_r( \
+ if (re_debug_flags & RE_DEBUG_EXTRA_BUFFERS) x )
+
+#define DEBUG_OPTIMISE_MORE_r(x) DEBUG_r( \
+ if ((RE_DEBUG_EXTRA_OPTIMISE|RE_DEBUG_COMPILE_OPTIMISE) == \
+ (re_debug_flags & (RE_DEBUG_EXTRA_OPTIMISE|RE_DEBUG_COMPILE_OPTIMISE)) ) x )
+#define MJD_OFFSET_DEBUG(x) DEBUG_r( \
+ if (re_debug_flags & RE_DEBUG_EXTRA_OFFDEBUG) \
+ Perl_warn_nocontext x )
+#define DEBUG_TRIE_COMPILE_MORE_r(x) DEBUG_TRIE_COMPILE_r( \
+ if (re_debug_flags & RE_DEBUG_EXTRA_TRIE) x )
+#define DEBUG_TRIE_EXECUTE_MORE_r(x) DEBUG_TRIE_EXECUTE_r( \
+ if (re_debug_flags & RE_DEBUG_EXTRA_TRIE) x )
+
+#define DEBUG_TRIE_r(x) DEBUG_r( \
+ if (re_debug_flags & (RE_DEBUG_COMPILE_TRIE \
+ | RE_DEBUG_EXECUTE_TRIE )) x )
+#define DEBUG_GPOS_r(x) DEBUG_r( \
+ if (re_debug_flags & RE_DEBUG_EXTRA_GPOS) x )
+
+/* initialization */
+/* get_sv() can return NULL during global destruction. */
+#define GET_RE_DEBUG_FLAGS DEBUG_r({ \
+ SV * re_debug_flags_sv = NULL; \
+ re_debug_flags_sv = get_sv(RE_DEBUG_FLAGS, 1); \
+ if (re_debug_flags_sv) { \
+ if (!SvIOK(re_debug_flags_sv)) \
+ sv_setuv(re_debug_flags_sv, RE_DEBUG_COMPILE_DUMP | RE_DEBUG_EXECUTE_MASK ); \
+ re_debug_flags=SvIV(re_debug_flags_sv); \
+ }\
+})
+
+#ifdef DEBUGGING
+
+#define GET_RE_DEBUG_FLAGS_DECL IV re_debug_flags = 0; GET_RE_DEBUG_FLAGS;
+
+#define RE_PV_COLOR_DECL(rpv,rlen,isuni,dsv,pv,l,m,c1,c2) \
+ const char * const rpv = \
+ pv_pretty((dsv), (pv), (l), (m), \
+ PL_colors[(c1)],PL_colors[(c2)], \
+ PERL_PV_ESCAPE_RE |((isuni) ? PERL_PV_ESCAPE_UNI : 0) ); \
+ const int rlen = SvCUR(dsv)
+
+#define RE_SV_ESCAPE(rpv,isuni,dsv,sv,m) \
+ const char * const rpv = \
+ pv_pretty((dsv), (SvPV_nolen_const(sv)), (SvCUR(sv)), (m), \
+ PL_colors[(c1)],PL_colors[(c2)], \
+ PERL_PV_ESCAPE_RE |((isuni) ? PERL_PV_ESCAPE_UNI : 0) )
+
+#define RE_PV_QUOTED_DECL(rpv,isuni,dsv,pv,l,m) \
+ const char * const rpv = \
+ pv_pretty((dsv), (pv), (l), (m), \
+ PL_colors[0], PL_colors[1], \
+ ( PERL_PV_PRETTY_QUOTE | PERL_PV_ESCAPE_RE | PERL_PV_PRETTY_ELLIPSES | \
+ ((isuni) ? PERL_PV_ESCAPE_UNI : 0)) \
+ )
+
+#define RE_SV_DUMPLEN(ItEm) (SvCUR(ItEm) - (SvTAIL(ItEm)!=0))
+#define RE_SV_TAIL(ItEm) (SvTAIL(ItEm) ? "$" : "")
+
+#else /* if not DEBUGGING */
+
+#define GET_RE_DEBUG_FLAGS_DECL
+#define RE_PV_COLOR_DECL(rpv,rlen,isuni,dsv,pv,l,m,c1,c2)
+#define RE_SV_ESCAPE(rpv,isuni,dsv,sv,m)
+#define RE_PV_QUOTED_DECL(rpv,isuni,dsv,pv,l,m)
+#define RE_SV_DUMPLEN(ItEm)
+#define RE_SV_TAIL(ItEm)
+
+#endif /* DEBUG RELATED DEFINES */
+
+/*
+ * Local variables:
+ * c-indentation-style: bsd
+ * c-basic-offset: 4
+ * indent-tabs-mode: t
+ * End:
+ *
+ * ex: set ts=8 sts=4 sw=4 noet:
+ */
https://perl5.git.perl.org / perl5.git / blobdiff