This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Re: sitecustomize.pl [PATCH]
[perl5.git] / regcomp.h
CommitLineData
a0d0e21e 1/* regcomp.h
d6376244 2 *
4bb101f2
JH
3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 * 2000, 2001, 2002, 2003, by Larry Wall and others
d6376244
JH
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
LW
9 */
10
c277df42
IZ
11typedef OP OP_4tree; /* Will be redefined later. */
12
a687059c
LW
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
LW
19 * reganch is the match anchored (at beginning-of-line only)?
20 * regmust string (pointer into program) that match must include, or NULL
79072805 21 * [regmust changed to SV* for bminstr()--law]
a687059c
LW
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
LW
29 * potentially expensive (at present, the only such thing detected is * or +
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
LW
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
LW
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
LW
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 75struct regnode_string {
cd439c50 76 U8 str_len;
c277df42
IZ
77 U8 type;
78 U16 next_off;
cd439c50 79 char string[1];
c277df42 80};
a687059c 81
c277df42
IZ
82struct regnode_1 {
83 U8 flags;
84 U8 type;
85 U16 next_off;
86 U32 arg1;
87};
88
89struct 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 (8*4) named classes */
936ed897
IZ
99
100struct 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
IZ
106};
107
19103b91
JH
108struct regnode_charclass_class { /* has [[:blah:]] classes */
109 U8 flags; /* should have ANYOF_CLASS here */
936ed897
IZ
110 U8 type;
111 U16 next_off;
ffc61ed2 112 U32 arg1;
19103b91
JH
113 char bitmap[ANYOF_BITMAP_SIZE]; /* both compile-time */
114 char classflags[ANYOF_CLASSBITMAP_SIZE]; /* and run-time */
936ed897
IZ
115};
116
9c7e81e8
AD
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
IZ
136# define REG_INFTY I16_MAX
137#endif
a687059c 138
e91177ed
IZ
139#define ARG_VALUE(arg) (arg)
140#define ARG__SET(arg,val) ((arg) = (val))
c277df42 141
e8e3b0fb
JH
142#undef ARG
143#undef ARG1
144#undef ARG2
145
c277df42
IZ
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
JH
153#undef NEXT_OFF
154#undef NODE_ALIGN
155
c277df42 156#ifndef lint
e91177ed
IZ
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
IZ
162# define NODE_ALIGN(node)
163# define NODE_ALIGN_FILL(node)
a687059c
LW
164#endif /* lint */
165
c277df42
IZ
166#define SIZE_ALIGN NODE_ALIGN
167
e8e3b0fb
JH
168#undef OP
169#undef OPERAND
170#undef MASK
171#undef STRING
172
e91177ed
IZ
173#define OP(p) ((p)->type)
174#define OPERAND(p) (((struct regnode_string *)p)->string)
cd439c50
IZ
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
JH
181#undef NODE_ALIGN
182#undef ARG_LOC
183#undef NEXTOPER
184#undef PREVOPER
185
e91177ed
IZ
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
IZ
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
JH
210#define ANYOF_INVERT 0x04
211#define ANYOF_FOLD 0x02
212#define ANYOF_LOCALE 0x01
b8c5462f 213
653099ff 214/* Used for regstclass only */
ffc61ed2
JH
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
HS
221/* size of node is large (includes class pointer) */
222#define ANYOF_LARGE 0x80
223
ffc61ed2
JH
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
GS
230/* Should be synchronized with a table in regprop() */
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
JH
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
JH
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
JF
259#define ANYOF_PSXSPC 26 /* POSIX space: \s plus the vertical tab */
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
JH
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
IZ
275#define ANYOF_SIZE (sizeof(struct regnode_charclass))
276#define ANYOF_CLASS_SIZE (sizeof(struct regnode_charclass_class))
b8c5462f 277
936ed897 278#define ANYOF_FLAGS(p) ((p)->flags)
b8c5462f
JH
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
JH
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
IZ
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
JH
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
NC
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
IZ
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
LW
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
LW
316#endif
317#else /* lint */
6b88bc9c 318#define UCHARAT(p) PL_regdummy
a687059c
LW
319#endif /* lint */
320
c277df42
IZ
321#define EXTRA_SIZE(guy) ((sizeof(guy)-1)/sizeof(struct regnode))
322
3baa4c62
JH
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
JH
327#define REG_SEEN_CANY 16
328#define REG_SEEN_SANY REG_SEEN_CANY /* src bckwrd cmpt */
d09b2d29 329
73c4f7a1
GS
330START_EXTERN_C
331
d09b2d29
IZ
332#include "regnodes.h"
333
4d61ec05 334/* The following have no fixed length. U8 so we can do strchr() on it. */
d09b2d29 335#ifndef DOINIT
4d61ec05 336EXTCONST U8 PL_varies[];
d09b2d29 337#else
4d61ec05 338EXTCONST 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
GS
344/* The following always have a length of 1. U8 we can do strchr() on it. */
345/* (Note that length 1 means "one character" under UTF8, not "one octet".) */
d09b2d29 346#ifndef DOINIT
4d61ec05 347EXTCONST U8 PL_simple[];
d09b2d29 348#else
4d61ec05 349EXTCONST U8 PL_simple[] = {
f33976b4 350 REG_ANY, SANY, CANY,
ffc61ed2
JH
351 ANYOF,
352 ALNUM, ALNUML,
353 NALNUM, NALNUML,
354 SPACE, SPACEL,
355 NSPACE, NSPACEL,
356 DIGIT, NDIGIT,
357 0
c277df42
IZ
358};
359#endif
360
73c4f7a1 361END_EXTERN_C
cad2e5aa
JH
362
363typedef 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
MJD
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
JH
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
JH
381struct reg_data {
382 U32 count;
383 U8 *what;
384 void* data[1];
385};
386
387struct reg_substr_datum {
388 I32 min_offset;
389 I32 max_offset;
33b8afdf
JH
390 SV *substr; /* non-utf8 variant */
391 SV *utf8_substr; /* utf8 variant */
cad2e5aa
JH
392};
393
394struct 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
JH
400#define anchored_offset substrs->data[0].min_offset
401#define float_substr substrs->data[1].substr
33b8afdf 402#define float_utf8 substrs->data[1].utf8_substr
cad2e5aa
JH
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
JH
407#define check_offset_min substrs->data[2].min_offset
408#define check_offset_max substrs->data[2].max_offset