[p5sagit/p5-mst-13.2.git] / regcomp.h

/*    regcomp.h
 *
 *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
 *    2000, 2001, 2002, 2003, 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.
 *
 */

typedef OP OP_4tree;			/* Will be redefined later. */

/*
 * 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
 * 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]
 * regmlen	length of regmust string
 *  [regmlen not used currently]
 *
 * Regstart and reganch permit very fast decisions on suitable starting points
 * for a match, cutting down the work a lot.  Regmust permits fast rejection
 * of lines that cannot possibly match.  The regmust tests are costly enough
 * that pregcomp() supplies a regmust only if the r.e. contains something
 * potentially expensive (at present, the only such thing detected is * or +
 * at the start of the r.e., which can involve a lot of backup).  Regmlen is
 * supplied because the test in pregexec() needs it and pregcomp() is computing
 * it anyway.
 * [regmust is now supplied always.  The tests that use regmust have a
 * heuristic that disables the test if it usually matches.]
 *
 * [In fact, we now use regmust in many cases to locate where the search
 * starts in the string, so if regback is >= 0, the regmust search is never
 * wasted effort.  The regback variable says how many characters back from
 * where regmust matched is the earliest possible start of the match.
 * For instance, /[a-z].foo/ has a regmust of 'foo' and a regback of 2.]
 */

/*
 * Structure for regexp "program".  This is essentially a linear encoding
 * of a nondeterministic finite-state machine (aka syntax charts or
 * "railroad normal form" in parsing technology).  Each node is an opcode
 * plus a "next" pointer, possibly plus an operand.  "Next" pointers of
 * all nodes except BRANCH implement concatenation; a "next" pointer with
 * a BRANCH on both ends of it is connecting two alternatives.  (Here we
 * have one of the subtle syntax dependencies:  an individual BRANCH (as
 * opposed to a collection of them) is never concatenated with anything
 * because of operator precedence.)  The operand of some types of node is
 * 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:
 */

/*
 * 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
 * value is a positive offset from the opcode of the node containing it.
 * An operand, if any, simply follows the node.  (Note that much of the
 * code generation knows about this implicit relationship.)
 *
 * Using two bytes for the "next" pointer is vast overkill for most things,
 * but allows patterns to get big without disasters.
 *
 * [The "next" pointer is always aligned on an even
 * boundary, and reads the offset directly as a short.  Also, there is no
 * special test to reverse the sign of BACK pointers since the offset is
 * stored negative.]
 */

struct regnode_string {
    U8	str_len;
    U8  type;
    U16 next_off;
    char string[1];
};

struct regnode_1 {
    U8	flags;
    U8  type;
    U16 next_off;
    U32 arg1;
};

struct regnode_2 {
    U8	flags;
    U8  type;
    U16 next_off;
    U16 arg1;
    U16 arg2;
};

#define ANYOF_BITMAP_SIZE	32	/* 256 b/(8 b/B) */
#define ANYOF_CLASSBITMAP_SIZE	 4	/* up to 32 (8*4) named classes */

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 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))

#undef NEXT_OFF
#undef NODE_ALIGN

#ifndef lint
#  define NEXT_OFF(p) ((p)->next_off)
#  define NODE_ALIGN(node)
#  define NODE_ALIGN_FILL(node) ((node)->flags = 0xde) /* deadbeef */
#else /* lint */
#  define NEXT_OFF(p) 0
#  define NODE_ALIGN(node)
#  define NODE_ALIGN_FILL(node)
#endif /* lint */

#define SIZE_ALIGN NODE_ALIGN

#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 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)

#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 { \
    ARG_SET(ptr, arg);  FILL_ADVANCE_NODE(ptr, op); (ptr) += 1; } STMT_END

#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
#define ANYOF_NDIGIT	 5
#define ANYOF_ALNUMC	 6	/* 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

/* 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)[((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)

/*
 * Utility definitions.
 */
#ifndef lint
#ifndef CHARMASK
#define	UCHARAT(p)	((int)*(U8*)(p))
#else
#define	UCHARAT(p)	((int)*(p)&CHARMASK)
#endif
#else /* lint */
#define UCHARAT(p)	PL_regdummy
#endif /* lint */

#define EXTRA_SIZE(guy) ((sizeof(guy)-1)/sizeof(struct regnode))

#define REG_SEEN_ZERO_LEN	 1
#define REG_SEEN_LOOKBEHIND	 2
#define REG_SEEN_GPOS		 4
#define REG_SEEN_EVAL		 8
#define REG_SEEN_CANY		16
#define REG_SEEN_SANY		REG_SEEN_CANY /* src bckwrd cmpt */

START_EXTERN_C

#include "regnodes.h"

/* The following have no fixed length. U8 so we can do strchr() on it. */
#ifndef DOINIT
EXTCONST U8 PL_varies[];
#else
EXTCONST U8 PL_varies[] = {
    BRANCH, BACK, STAR, PLUS, CURLY, CURLYX, REF, REFF, REFFL, 
    WHILEM, CURLYM, CURLYN, BRANCHJ, IFTHEN, SUSPEND, CLUMP, 0
};
#endif

/* The following always have a length of 1. U8 we can do strchr() on it. */
/* (Note that length 1 means "one character" under UTF8, not "one octet".) */
#ifndef DOINIT
EXTCONST U8 PL_simple[];
#else
EXTCONST U8 PL_simple[] = {
    REG_ANY,	SANY,	CANY,
    ANYOF,
    ALNUM,	ALNUML,
    NALNUM,	NALNUML,
    SPACE,	SPACEL,
    NSPACE,	NSPACEL,
    DIGIT,	NDIGIT,
    0
};
#endif

END_EXTERN_C

typedef struct re_scream_pos_data_s
{
    char **scream_olds;		/* match pos */
    I32 *scream_pos;		/* Internal iterator of scream. */
} re_scream_pos_data;

/* .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
 * 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];
};

struct reg_substr_datum {
    I32 min_offset;
    I32 max_offset;
    SV *substr;		/* non-utf8 variant */
    SV *utf8_substr;	/* utf8 variant */
};

struct reg_substr_data {
    struct reg_substr_datum data[3];	/* Actual array */
};

#define anchored_substr substrs->data[0].substr
#define anchored_utf8 substrs->data[0].utf8_substr
#define anchored_offset substrs->data[0].min_offset
#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 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
Commit	Line	Data
a0d0e21e	1	/* regcomp.h
d6376244	2	*
4bb101f2	3	* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4bb101f2	4	* 2000, 2001, 2002, 2003, by Larry Wall and others
d6376244	5	*
	6	* You may distribute under the terms of either the GNU General Public
	7	* License or the Artistic License, as specified in the README file.
	8	*
a687059c	9	*/
a687059c	10
c277df42	11	typedef OP OP_4tree; /* Will be redefined later. */
c277df42	12
a687059c	13	/*
	14	* The "internal use only" fields in regexp.h are present to pass info from
	15	* compile to execute that permits the execute phase to run lots faster on
	16	* simple cases. They are:
	17	*
79072805	18	* regstart sv that must begin a match; Nullch if none obvious
a687059c	19	* reganch is the match anchored (at beginning-of-line only)?
a687059c	20	* regmust string (pointer into program) that match must include, or NULL
79072805	21	* [regmust changed to SV* for bminstr()--law]
a687059c	22	* regmlen length of regmust string
	23	* [regmlen not used currently]
	24	*
	25	* Regstart and reganch permit very fast decisions on suitable starting points
	26	* for a match, cutting down the work a lot. Regmust permits fast rejection
	27	* of lines that cannot possibly match. The regmust tests are costly enough
e50aee73	28	* that pregcomp() supplies a regmust only if the r.e. contains something
a687059c	29	* potentially expensive (at present, the only such thing detected is * or +
a687059c	30	* at the start of the r.e., which can involve a lot of backup). Regmlen is
e50aee73	31	* supplied because the test in pregexec() needs it and pregcomp() is computing
a687059c	32	* it anyway.
	33	* [regmust is now supplied always. The tests that use regmust have a
	34	* heuristic that disables the test if it usually matches.]
	35	*
	36	* [In fact, we now use regmust in many cases to locate where the search
	37	* starts in the string, so if regback is >= 0, the regmust search is never
	38	* wasted effort. The regback variable says how many characters back from
	39	* where regmust matched is the earliest possible start of the match.
	40	* For instance, /[a-z].foo/ has a regmust of 'foo' and a regback of 2.]
	41	*/
	42
	43	/*
	44	* Structure for regexp "program". This is essentially a linear encoding
	45	* of a nondeterministic finite-state machine (aka syntax charts or
	46	* "railroad normal form" in parsing technology). Each node is an opcode
	47	* plus a "next" pointer, possibly plus an operand. "Next" pointers of
	48	* all nodes except BRANCH implement concatenation; a "next" pointer with
	49	* a BRANCH on both ends of it is connecting two alternatives. (Here we
	50	* have one of the subtle syntax dependencies: an individual BRANCH (as
	51	* opposed to a collection of them) is never concatenated with anything
	52	* because of operator precedence.) The operand of some types of node is
	53	* a literal string; for others, it is a node leading into a sub-FSM. In
	54	* particular, the operand of a BRANCH node is the first node of the branch.
	55	* (NB this is not a tree structure: the tail of the branch connects
	56	* to the thing following the set of BRANCHes.) The opcodes are:
	57	*/
	58
a687059c	59	/*
	60	* A node is one char of opcode followed by two chars of "next" pointer.
	61	* "Next" pointers are stored as two 8-bit pieces, high order first. The
	62	* value is a positive offset from the opcode of the node containing it.
	63	* An operand, if any, simply follows the node. (Note that much of the
	64	* code generation knows about this implicit relationship.)
	65	*
	66	* Using two bytes for the "next" pointer is vast overkill for most things,
	67	* but allows patterns to get big without disasters.
	68	*
e91177ed	69	* [The "next" pointer is always aligned on an even
a687059c	70	* boundary, and reads the offset directly as a short. Also, there is no
	71	* special test to reverse the sign of BACK pointers since the offset is
	72	* stored negative.]
	73	*/
	74
c277df42	75	struct regnode_string {
cd439c50	76	U8 str_len;
c277df42	77	U8 type;
c277df42	78	U16 next_off;
cd439c50	79	char string[1];
c277df42	80	};
a687059c	81
c277df42	82	struct regnode_1 {
	83	U8 flags;
	84	U8 type;
	85	U16 next_off;
	86	U32 arg1;
	87	};
	88
	89	struct regnode_2 {
	90	U8 flags;
	91	U8 type;
	92	U16 next_off;
	93	U16 arg1;
	94	U16 arg2;
	95	};
	96
936ed897	97	#define ANYOF_BITMAP_SIZE 32 /* 256 b/(8 b/B) */
ffc61ed2	98	#define ANYOF_CLASSBITMAP_SIZE 4 /* up to 32 (84) named classes /
936ed897	99
	100	struct regnode_charclass {
	101	U8 flags;
	102	U8 type;
	103	U16 next_off;
ffc61ed2	104	U32 arg1;
19103b91	105	char bitmap[ANYOF_BITMAP_SIZE]; /* only compile-time */
936ed897	106	};
936ed897	107
19103b91	108	struct regnode_charclass_class { /* has [[:blah:]] classes */
19103b91	109	U8 flags; /* should have ANYOF_CLASS here */
936ed897	110	U8 type;
936ed897	111	U16 next_off;
ffc61ed2	112	U32 arg1;
19103b91	113	char bitmap[ANYOF_BITMAP_SIZE]; /* both compile-time */
19103b91	114	char classflags[ANYOF_CLASSBITMAP_SIZE]; /* and run-time */
936ed897	115	};
936ed897	116
9c7e81e8	117	/* XXX fix this description.
	118	Impose a limit of REG_INFTY on various pattern matching operations
	119	to limit stack growth and to avoid "infinite" recursions.
	120	*/
	121	/* The default size for REG_INFTY is I16_MAX, which is the same as
	122	SHORT_MAX (see perl.h). Unfortunately I16 isn't necessarily 16 bits
	123	(see handy.h). On the Cray C90, sizeof(short)==4 and hence I16_MAX is
	124	((1<<31)-1), while on the Cray T90, sizeof(short)==8 and I16_MAX is
	125	((1<<63)-1). To limit stack growth to reasonable sizes, supply a
	126	smaller default.
	127	--Andy Dougherty 11 June 1998
	128	*/
	129	#if SHORTSIZE > 2
	130	# ifndef REG_INFTY
	131	# define REG_INFTY ((1<<15)-1)
	132	# endif
	133	#endif
	134
	135	#ifndef REG_INFTY
83cfe48c	136	# define REG_INFTY I16_MAX
83cfe48c	137	#endif
a687059c	138
e91177ed	139	#define ARG_VALUE(arg) (arg)
e91177ed	140	#define ARG__SET(arg,val) ((arg) = (val))
c277df42	141
e8e3b0fb	142	#undef ARG
	143	#undef ARG1
	144	#undef ARG2
	145
c277df42	146	#define ARG(p) ARG_VALUE(ARG_LOC(p))
	147	#define ARG1(p) ARG_VALUE(ARG1_LOC(p))
	148	#define ARG2(p) ARG_VALUE(ARG2_LOC(p))
	149	#define ARG_SET(p, val) ARG__SET(ARG_LOC(p), (val))
	150	#define ARG1_SET(p, val) ARG__SET(ARG1_LOC(p), (val))
	151	#define ARG2_SET(p, val) ARG__SET(ARG2_LOC(p), (val))
	152
e8e3b0fb	153	#undef NEXT_OFF
	154	#undef NODE_ALIGN
	155
c277df42	156	#ifndef lint
e91177ed	157	# define NEXT_OFF(p) ((p)->next_off)
	158	# define NODE_ALIGN(node)
	159	# define NODE_ALIGN_FILL(node) ((node)->flags = 0xde) /* deadbeef */
a687059c	160	#else /* lint */
c277df42	161	# define NEXT_OFF(p) 0
e91177ed	162	# define NODE_ALIGN(node)
e91177ed	163	# define NODE_ALIGN_FILL(node)
a687059c	164	#endif /* lint */
a687059c	165
c277df42	166	#define SIZE_ALIGN NODE_ALIGN
c277df42	167
e8e3b0fb	168	#undef OP
	169	#undef OPERAND
	170	#undef MASK
	171	#undef STRING
	172
e91177ed	173	#define OP(p) ((p)->type)
e91177ed	174	#define OPERAND(p) (((struct regnode_string *)p)->string)
cd439c50	175	#define MASK(p) ((char*)OPERAND(p))
	176	#define STR_LEN(p) (((struct regnode_string *)p)->str_len)
	177	#define STRING(p) (((struct regnode_string *)p)->string)
	178	#define STR_SZ(l) ((l + sizeof(regnode) - 1) / sizeof(regnode))
	179	#define NODE_SZ_STR(p) (STR_SZ(STR_LEN(p))+1)
	180
e8e3b0fb	181	#undef NODE_ALIGN
	182	#undef ARG_LOC
	183	#undef NEXTOPER
	184	#undef PREVOPER
	185
e91177ed	186	#define NODE_ALIGN(node)
	187	#define ARG_LOC(p) (((struct regnode_1 *)p)->arg1)
	188	#define ARG1_LOC(p) (((struct regnode_2 *)p)->arg1)
	189	#define ARG2_LOC(p) (((struct regnode_2 *)p)->arg2)
	190	#define NODE_STEP_REGNODE 1 /* sizeof(regnode)/sizeof(regnode) */
	191	#define EXTRA_STEP_2ARGS EXTRA_SIZE(struct regnode_2)
	192
	193	#define NODE_STEP_B 4
c277df42	194
	195	#define NEXTOPER(p) ((p) + NODE_STEP_REGNODE)
	196	#define PREVOPER(p) ((p) - NODE_STEP_REGNODE)
	197
e91177ed	198	#define FILL_ADVANCE_NODE(ptr, op) STMT_START { \
c277df42	199	(ptr)->type = op; (ptr)->next_off = 0; (ptr)++; } STMT_END
e91177ed	200	#define FILL_ADVANCE_NODE_ARG(ptr, op, arg) STMT_START { \
c277df42	201	ARG_SET(ptr, arg); FILL_ADVANCE_NODE(ptr, op); (ptr) += 1; } STMT_END
a687059c	202
22c35a8c	203	#define REG_MAGIC 0234
a687059c	204
830247a4	205	#define SIZE_ONLY (RExC_emit == &PL_regdummy)
c277df42	206
936ed897	207	/* Flags for node->flags of ANYOF */
b8c5462f	208
19103b91	209	#define ANYOF_CLASS 0x08 /* has [[:blah:]] classes */
ffc61ed2	210	#define ANYOF_INVERT 0x04
	211	#define ANYOF_FOLD 0x02
	212	#define ANYOF_LOCALE 0x01
b8c5462f	213
653099ff	214	/* Used for regstclass only */
ffc61ed2	215	#define ANYOF_EOS 0x10 /* Can match an empty string too */
	216
	217	/* There is a character or a range past 0xff */
	218	#define ANYOF_UNICODE 0x20
1aa99e6b	219	#define ANYOF_UNICODE_ALL 0x40 /* Can match any char past 0xff */
ffc61ed2	220
4f66b38d	221	/* size of node is large (includes class pointer) */
	222	#define ANYOF_LARGE 0x80
	223
ffc61ed2	224	/* Are there any runtime flags on in this node? */
	225	#define ANYOF_RUNTIME(s) (ANYOF_FLAGS(s) & 0x0f)
	226
	227	#define ANYOF_FLAGS_ALL 0xff
653099ff	228
936ed897	229	/* Character classes for node->classflags of ANYOF */
653099ff	230	/* Should be synchronized with a table in regprop() */
653099ff	231	/* 2n should pair with 2n+1 */
b8c5462f	232
289d4f09	233	#define ANYOF_ALNUM 0 /* \w, PL_utf8_alnum, utf8::IsWord, ALNUM */
b8c5462f	234	#define ANYOF_NALNUM 1
aaa51d5e	235	#define ANYOF_SPACE 2 /* \s */
b8c5462f	236	#define ANYOF_NSPACE 3
	237	#define ANYOF_DIGIT 4
	238	#define ANYOF_NDIGIT 5
289d4f09	239	#define ANYOF_ALNUMC 6 /* isalnum(3), utf8::IsAlnum, ALNUMC */
b8c5462f	240	#define ANYOF_NALNUMC 7
	241	#define ANYOF_ALPHA 8
	242	#define ANYOF_NALPHA 9
	243	#define ANYOF_ASCII 10
	244	#define ANYOF_NASCII 11
	245	#define ANYOF_CNTRL 12
	246	#define ANYOF_NCNTRL 13
	247	#define ANYOF_GRAPH 14
	248	#define ANYOF_NGRAPH 15
	249	#define ANYOF_LOWER 16
	250	#define ANYOF_NLOWER 17
	251	#define ANYOF_PRINT 18
	252	#define ANYOF_NPRINT 19
	253	#define ANYOF_PUNCT 20
	254	#define ANYOF_NPUNCT 21
	255	#define ANYOF_UPPER 22
	256	#define ANYOF_NUPPER 23
	257	#define ANYOF_XDIGIT 24
	258	#define ANYOF_NXDIGIT 25
aaa51d5e	259	#define ANYOF_PSXSPC 26 /* POSIX space: \s plus the vertical tab */
aaa51d5e	260	#define ANYOF_NPSXSPC 27
ffc61ed2	261	#define ANYOF_BLANK 28 /* GNU extension: space and tab: non-vertical space */
289d4f09	262	#define ANYOF_NBLANK 29
b8c5462f	263
aaa51d5e	264	#define ANYOF_MAX 32
b8c5462f	265
	266	/* Backward source code compatibility. */
	267
	268	#define ANYOF_ALNUML ANYOF_ALNUM
	269	#define ANYOF_NALNUML ANYOF_NALNUM
	270	#define ANYOF_SPACEL ANYOF_SPACE
	271	#define ANYOF_NSPACEL ANYOF_NSPACE
	272
	273	/* Utility macros for the bitmap and classes of ANYOF */
	274
936ed897	275	#define ANYOF_SIZE (sizeof(struct regnode_charclass))
936ed897	276	#define ANYOF_CLASS_SIZE (sizeof(struct regnode_charclass_class))
b8c5462f	277
936ed897	278	#define ANYOF_FLAGS(p) ((p)->flags)
b8c5462f	279
	280	#define ANYOF_BIT(c) (1 << ((c) & 7))
	281
936ed897	282	#define ANYOF_CLASS_BYTE(p, c) (((struct regnode_charclass_class*)(p))->classflags[((c) >> 3) & 3])
b8c5462f	283	#define ANYOF_CLASS_SET(p, c) (ANYOF_CLASS_BYTE(p, c) \|= ANYOF_BIT(c))
	284	#define ANYOF_CLASS_CLEAR(p, c) (ANYOF_CLASS_BYTE(p, c) &= ~ANYOF_BIT(c))
	285	#define ANYOF_CLASS_TEST(p, c) (ANYOF_CLASS_BYTE(p, c) & ANYOF_BIT(c))
	286
936ed897	287	#define ANYOF_CLASS_ZERO(ret) Zero(((struct regnode_charclass_class*)(ret))->classflags, ANYOF_CLASSBITMAP_SIZE, char)
	288	#define ANYOF_BITMAP_ZERO(ret) Zero(((struct regnode_charclass*)(ret))->bitmap, ANYOF_BITMAP_SIZE, char)
	289
	290	#define ANYOF_BITMAP(p) (((struct regnode_charclass*)(p))->bitmap)
	291	#define ANYOF_BITMAP_BYTE(p, c) (ANYOF_BITMAP(p)[((c) >> 3) & 31])
b8c5462f	292	#define ANYOF_BITMAP_SET(p, c) (ANYOF_BITMAP_BYTE(p, c) \|= ANYOF_BIT(c))
	293	#define ANYOF_BITMAP_CLEAR(p,c) (ANYOF_BITMAP_BYTE(p, c) &= ~ANYOF_BIT(c))
	294	#define ANYOF_BITMAP_TEST(p, c) (ANYOF_BITMAP_BYTE(p, c) & ANYOF_BIT(c))
	295
f8bef550	296	#define ANYOF_BITMAP_SETALL(p) \
	297	memset (ANYOF_BITMAP(p), 255, ANYOF_BITMAP_SIZE)
	298	#define ANYOF_BITMAP_CLEARALL(p) \
	299	Zero (ANYOF_BITMAP(p), ANYOF_BITMAP_SIZE)
	300	/* Check that all 256 bits are all set. Used in S_cl_is_anything() */
	301	#define ANYOF_BITMAP_TESTALLSET(p) \
	302	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)
	303
936ed897	304	#define ANYOF_SKIP ((ANYOF_SIZE - 1)/sizeof(regnode))
	305	#define ANYOF_CLASS_SKIP ((ANYOF_CLASS_SIZE - 1)/sizeof(regnode))
	306	#define ANYOF_CLASS_ADD_SKIP (ANYOF_CLASS_SKIP - ANYOF_SKIP)
c277df42	307
a687059c	308	/*
	309	* Utility definitions.
	310	*/
	311	#ifndef lint
2304df62	312	#ifndef CHARMASK
4d61ec05	313	#define UCHARAT(p) ((int)(U8)(p))
a687059c	314	#else
2304df62	315	#define UCHARAT(p) ((int)*(p)&CHARMASK)
a687059c	316	#endif
a687059c	317	#else /* lint */
6b88bc9c	318	#define UCHARAT(p) PL_regdummy
a687059c	319	#endif /* lint */
a687059c	320
c277df42	321	#define EXTRA_SIZE(guy) ((sizeof(guy)-1)/sizeof(struct regnode))
c277df42	322
3baa4c62	323	#define REG_SEEN_ZERO_LEN 1
	324	#define REG_SEEN_LOOKBEHIND 2
	325	#define REG_SEEN_GPOS 4
	326	#define REG_SEEN_EVAL 8
cce850e4	327	#define REG_SEEN_CANY 16
cce850e4	328	#define REG_SEEN_SANY REG_SEEN_CANY /* src bckwrd cmpt */
d09b2d29	329
73c4f7a1	330	START_EXTERN_C
73c4f7a1	331
d09b2d29	332	#include "regnodes.h"
d09b2d29	333
4d61ec05	334	/* The following have no fixed length. U8 so we can do strchr() on it. */
d09b2d29	335	#ifndef DOINIT
4d61ec05	336	EXTCONST U8 PL_varies[];
d09b2d29	337	#else
4d61ec05	338	EXTCONST U8 PL_varies[] = {
d09b2d29	339	BRANCH, BACK, STAR, PLUS, CURLY, CURLYX, REF, REFF, REFFL,
a0ed51b3	340	WHILEM, CURLYM, CURLYN, BRANCHJ, IFTHEN, SUSPEND, CLUMP, 0
c277df42	341	};
d09b2d29	342	#endif
c277df42	343
4d61ec05	344	/* The following always have a length of 1. U8 we can do strchr() on it. */
4d61ec05	345	/* (Note that length 1 means "one character" under UTF8, not "one octet".) */
d09b2d29	346	#ifndef DOINIT
4d61ec05	347	EXTCONST U8 PL_simple[];
d09b2d29	348	#else
4d61ec05	349	EXTCONST U8 PL_simple[] = {
f33976b4	350	REG_ANY, SANY, CANY,
ffc61ed2	351	ANYOF,
	352	ALNUM, ALNUML,
	353	NALNUM, NALNUML,
	354	SPACE, SPACEL,
	355	NSPACE, NSPACEL,
	356	DIGIT, NDIGIT,
	357	0
c277df42	358	};
	359	#endif
	360
73c4f7a1	361	END_EXTERN_C
cad2e5aa	362
	363	typedef struct re_scream_pos_data_s
	364	{
	365	char *scream_olds; / match pos */
	366	I32 scream_pos; / Internal iterator of scream. */
	367	} re_scream_pos_data;
	368
261faec3	369	/* .what is a character array with one character for each member of .data
	370	* The character describes the function of the corresponding .data item:
	371	* f - start-class data for regstclass optimization
	372	* n - Root of op tree for (?{EVAL}) item
	373	* o - Start op for (?{EVAL}) item
	374	* p - Pad for (?{EVAL} item
9e55ce06	375	* s - swash for unicode-style character class, and the multicharacter
	376	* strings resulting from casefolding the single-character entries
	377	* in the character class
261faec3	378	* 20010712 mjd@plover.com
c3613ed7	379	* (Remember to update re_dup() and pregfree() if you add any items.)
261faec3	380	*/
cad2e5aa	381	struct reg_data {
	382	U32 count;
	383	U8 *what;
	384	void* data[1];
	385	};
	386
	387	struct reg_substr_datum {
	388	I32 min_offset;
	389	I32 max_offset;
33b8afdf	390	SV substr; / non-utf8 variant */
33b8afdf	391	SV utf8_substr; / utf8 variant */
cad2e5aa	392	};
	393
	394	struct reg_substr_data {
	395	struct reg_substr_datum data[3]; /* Actual array */
	396	};
	397
	398	#define anchored_substr substrs->data[0].substr
33b8afdf	399	#define anchored_utf8 substrs->data[0].utf8_substr
cad2e5aa	400	#define anchored_offset substrs->data[0].min_offset
cad2e5aa	401	#define float_substr substrs->data[1].substr
33b8afdf	402	#define float_utf8 substrs->data[1].utf8_substr
cad2e5aa	403	#define float_min_offset substrs->data[1].min_offset
	404	#define float_max_offset substrs->data[1].max_offset
	405	#define check_substr substrs->data[2].substr
33b8afdf	406	#define check_utf8 substrs->data[2].utf8_substr
cad2e5aa	407	#define check_offset_min substrs->data[2].min_offset
cad2e5aa	408	#define check_offset_max substrs->data[2].max_offset