This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
move RXf_GPOS_SEEN and RXf_GPOS_FLOAT to intflags
[perl5.git] / regcomp.h
1 /*    regcomp.h
2  *
3  *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4  *    2000, 2001, 2002, 2003, 2005, 2006, 2007, by Larry Wall and others
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  *
9  */
10 #include "regcharclass.h"
11
12 /* Convert branch sequences to more efficient trie ops? */
13 #define PERL_ENABLE_TRIE_OPTIMISATION 1
14
15 /* Be really aggressive about optimising patterns with trie sequences? */
16 #define PERL_ENABLE_EXTENDED_TRIE_OPTIMISATION 1
17
18 /* Should the optimiser take positive assertions into account? */
19 #define PERL_ENABLE_POSITIVE_ASSERTION_STUDY 0
20
21 /* Not for production use: */
22 #define PERL_ENABLE_EXPERIMENTAL_REGEX_OPTIMISATIONS 0
23
24 /* Activate offsets code - set to if 1 to enable */
25 #ifdef DEBUGGING
26 #define RE_TRACK_PATTERN_OFFSETS
27 #endif
28
29 /*
30  * The "internal use only" fields in regexp.h are present to pass info from
31  * compile to execute that permits the execute phase to run lots faster on
32  * simple cases.  They are:
33  *
34  * regstart     sv that must begin a match; NULL if none obvious
35  * reganch      is the match anchored (at beginning-of-line only)?
36  * regmust      string (pointer into program) that match must include, or NULL
37  *  [regmust changed to SV* for bminstr()--law]
38  * regmlen      length of regmust string
39  *  [regmlen not used currently]
40  *
41  * Regstart and reganch permit very fast decisions on suitable starting points
42  * for a match, cutting down the work a lot.  Regmust permits fast rejection
43  * of lines that cannot possibly match.  The regmust tests are costly enough
44  * that pregcomp() supplies a regmust only if the r.e. contains something
45  * potentially expensive (at present, the only such thing detected is * or +
46  * at the start of the r.e., which can involve a lot of backup).  Regmlen is
47  * supplied because the test in pregexec() needs it and pregcomp() is computing
48  * it anyway.
49  * [regmust is now supplied always.  The tests that use regmust have a
50  * heuristic that disables the test if it usually matches.]
51  *
52  * [In fact, we now use regmust in many cases to locate where the search
53  * starts in the string, so if regback is >= 0, the regmust search is never
54  * wasted effort.  The regback variable says how many characters back from
55  * where regmust matched is the earliest possible start of the match.
56  * For instance, /[a-z].foo/ has a regmust of 'foo' and a regback of 2.]
57  */
58
59 /*
60  * Structure for regexp "program".  This is essentially a linear encoding
61  * of a nondeterministic finite-state machine (aka syntax charts or
62  * "railroad normal form" in parsing technology).  Each node is an opcode
63  * plus a "next" pointer, possibly plus an operand.  "Next" pointers of
64  * all nodes except BRANCH implement concatenation; a "next" pointer with
65  * a BRANCH on both ends of it is connecting two alternatives.  (Here we
66  * have one of the subtle syntax dependencies:  an individual BRANCH (as
67  * opposed to a collection of them) is never concatenated with anything
68  * because of operator precedence.)  The operand of some types of node is
69  * a literal string; for others, it is a node leading into a sub-FSM.  In
70  * particular, the operand of a BRANCH node is the first node of the branch.
71  * (NB this is *not* a tree structure:  the tail of the branch connects
72  * to the thing following the set of BRANCHes.)  The opcodes are defined
73  * in regnodes.h which is generated from regcomp.sym by regcomp.pl.
74  */
75
76 /*
77  * A node is one char of opcode followed by two chars of "next" pointer.
78  * "Next" pointers are stored as two 8-bit pieces, high order first.  The
79  * value is a positive offset from the opcode of the node containing it.
80  * An operand, if any, simply follows the node.  (Note that much of the
81  * code generation knows about this implicit relationship.)
82  *
83  * Using two bytes for the "next" pointer is vast overkill for most things,
84  * but allows patterns to get big without disasters.
85  *
86  * [The "next" pointer is always aligned on an even
87  * boundary, and reads the offset directly as a short.  Also, there is no
88  * special test to reverse the sign of BACK pointers since the offset is
89  * stored negative.]
90  */
91
92 /* This is the stuff that used to live in regexp.h that was truly
93    private to the engine itself. It now lives here. */
94
95
96
97  typedef struct regexp_internal {
98         int name_list_idx;      /* Optional data index of an array of paren names */
99         union {
100             U32 *offsets;           /* offset annotations 20001228 MJD
101                                        data about mapping the program to the
102                                        string -
103                                        offsets[0] is proglen when this is used
104                                        */
105             U32 proglen;
106         } u;
107
108         regnode *regstclass;    /* Optional startclass as identified or constructed
109                                    by the optimiser */
110         struct reg_data *data;  /* Additional miscellaneous data used by the program.
111                                    Used to make it easier to clone and free arbitrary
112                                    data that the regops need. Often the ARG field of
113                                    a regop is an index into this structure */
114         struct reg_code_block *code_blocks;/* positions of literal (?{}) */
115         int num_code_blocks;    /* size of code_blocks[] */
116         regnode program[1];     /* Unwarranted chumminess with compiler. */
117 } regexp_internal;
118
119 #define RXi_SET(x,y) (x)->pprivate = (void*)(y)   
120 #define RXi_GET(x)   ((regexp_internal *)((x)->pprivate))
121 #define RXi_GET_DECL(r,ri) regexp_internal *ri = RXi_GET(r)
122 /*
123  * Flags stored in regexp->intflags
124  * These are used only internally to the regexp engine
125  *
126  * See regexp.h for flags used externally to the regexp engine
127  */
128 #define RXp_INTFLAGS(rx)        ((rx)->intflags)
129 #define RX_INTFLAGS(prog)        RXp_INTFLAGS(ReANY(prog))
130
131 #define PREGf_SKIP              0x00000001
132 #define PREGf_IMPLICIT          0x00000002 /* Converted .* to ^.* */
133 #define PREGf_NAUGHTY           0x00000004 /* how exponential is this pattern? */
134 #define PREGf_VERBARG_SEEN      0x00000008
135 #define PREGf_CUTGROUP_SEEN     0x00000010
136 #define PREGf_USE_RE_EVAL       0x00000020 /* compiled with "use re 'eval'" */
137 /* these used to be extflags, but are now intflags */
138 #define PREGf_NOSCAN            0x00000040
139 #define PREGf_CANY_SEEN         0x00000080
140 #define PREGf_GPOS_SEEN           0x00000100
141 #define PREGf_GPOS_FLOAT          0x00000200
142
143
144 /* this is where the old regcomp.h started */
145
146 struct regnode_string {
147     U8  str_len;
148     U8  type;
149     U16 next_off;
150     char string[1];
151 };
152
153 /* Argument bearing node - workhorse, 
154    arg1 is often for the data field */
155 struct regnode_1 {
156     U8  flags;
157     U8  type;
158     U16 next_off;
159     U32 arg1;
160 };
161
162 /* Similar to a regnode_1 but with an extra signed argument */
163 struct regnode_2L {
164     U8  flags;
165     U8  type;
166     U16 next_off;
167     U32 arg1;
168     I32 arg2;
169 };
170
171 /* 'Two field' -- Two 16 bit unsigned args */
172 struct regnode_2 {
173     U8  flags;
174     U8  type;
175     U16 next_off;
176     U16 arg1;
177     U16 arg2;
178 };
179
180
181 #define ANYOF_BITMAP_SIZE       32      /* 256 b/(8 b/B) */
182
183 /* also used by trie */
184 struct regnode_charclass {
185     U8  flags;
186     U8  type;
187     U16 next_off;
188     U32 arg1;                           /* used as ptr in S_regclass */
189     char bitmap[ANYOF_BITMAP_SIZE];     /* only compile-time */
190 };
191
192 /* has runtime (locale) \d, \w, ..., [:posix:] classes */
193 struct regnode_charclass_class {
194     U8  flags;                          /* ANYOF_POSIXL bit must go here */
195     U8  type;
196     U16 next_off;
197     U32 arg1;                                   /* used as ptr in S_regclass */
198     char bitmap[ANYOF_BITMAP_SIZE];             /* both compile-time */
199     U32 classflags;                             /* and run-time */
200 };
201
202 /* like above, but also has folds that are used only if the runtime locale is
203  * UTF-8. */
204 struct regnode_charclass_posixl_fold {
205     U8  flags;                          /* ANYOF_POSIXL bit must go here */
206     U8  type;
207     U16 next_off;
208     U32 arg1;                           /* used as ptr in S_regclass */
209     char bitmap[ANYOF_BITMAP_SIZE];     /* both compile-time */
210     U32 classflags;                     /* and run-time */
211     SV* utf8_locale_list;               /* list of code points matched by folds
212                                            in a UTF-8 locale */
213 };
214
215 /* A synthetic start class; is a regnode_charclass_posixl_fold, plus an extra
216  * SV*, used only during its construction and which is not used by regexec.c.
217  * Note that the 'next_off' field is unused, as the SSC stands alone, so there
218  * is never a next node. */
219 struct regnode_ssc {
220     U8  flags;                          /* ANYOF_POSIXL bit must go here */
221     U8  type;
222     U16 next_off;
223     U32 arg1;                           /* used as ptr in S_regclass */
224     char bitmap[ANYOF_BITMAP_SIZE];     /* both compile-time */
225     U32 classflags;                     /* and run-time */
226     SV* utf8_locale_list;               /* list of code points matched by folds
227                                            in a UTF-8 locale */
228     SV* invlist;                        /* list of code points matched */
229 };
230
231 /*  We take advantage of 'next_off' not otherwise being used in the SSC by
232  *  actually using it: by setting it to 1.  This allows us to test and
233  *  distinguish between an SSC and other ANYOF node types, as 'next_off' cannot
234  *  otherwise be 1, because it is the offset to the next regnode expressed in
235  *  units of regnodes.  Since an ANYOF node contains extra fields, it adds up
236  *  to 12 regnode units on 32-bit systems, (hence the minimum this can be (if
237  *  not 0) is 11 there.  Even if things get tightly packed on a 64-bit system,
238  *  it still would be more than 1. */
239 #define set_ANYOF_SYNTHETIC(n) STMT_START{ OP(n) = ANYOF;              \
240                                            NEXT_OFF(n) = 1;            \
241                                } STMT_END
242 #define is_ANYOF_SYNTHETIC(n) (OP(n) == ANYOF && NEXT_OFF(n) == 1)
243
244 /* XXX fix this description.
245    Impose a limit of REG_INFTY on various pattern matching operations
246    to limit stack growth and to avoid "infinite" recursions.
247 */
248 /* The default size for REG_INFTY is I16_MAX, which is the same as
249    SHORT_MAX (see perl.h).  Unfortunately I16 isn't necessarily 16 bits
250    (see handy.h).  On the Cray C90, sizeof(short)==4 and hence I16_MAX is
251    ((1<<31)-1), while on the Cray T90, sizeof(short)==8 and I16_MAX is
252    ((1<<63)-1).  To limit stack growth to reasonable sizes, supply a
253    smaller default.
254         --Andy Dougherty  11 June 1998
255 */
256 #if SHORTSIZE > 2
257 #  ifndef REG_INFTY
258 #    define REG_INFTY ((1<<15)-1)
259 #  endif
260 #endif
261
262 #ifndef REG_INFTY
263 #  define REG_INFTY I16_MAX
264 #endif
265
266 #define ARG_VALUE(arg) (arg)
267 #define ARG__SET(arg,val) ((arg) = (val))
268
269 #undef ARG
270 #undef ARG1
271 #undef ARG2
272
273 #define ARG(p) ARG_VALUE(ARG_LOC(p))
274 #define ARG1(p) ARG_VALUE(ARG1_LOC(p))
275 #define ARG2(p) ARG_VALUE(ARG2_LOC(p))
276 #define ARG2L(p) ARG_VALUE(ARG2L_LOC(p))
277
278 #define ARG_SET(p, val) ARG__SET(ARG_LOC(p), (val))
279 #define ARG1_SET(p, val) ARG__SET(ARG1_LOC(p), (val))
280 #define ARG2_SET(p, val) ARG__SET(ARG2_LOC(p), (val))
281 #define ARG2L_SET(p, val) ARG__SET(ARG2L_LOC(p), (val))
282
283 #undef NEXT_OFF
284 #undef NODE_ALIGN
285
286 #define NEXT_OFF(p) ((p)->next_off)
287 #define NODE_ALIGN(node)
288 #define NODE_ALIGN_FILL(node) ((node)->flags = 0xde) /* deadbeef */
289
290 #define SIZE_ALIGN NODE_ALIGN
291
292 #undef OP
293 #undef OPERAND
294 #undef MASK
295 #undef STRING
296
297 #define OP(p)           ((p)->type)
298 #define FLAGS(p)        ((p)->flags)    /* Caution: Doesn't apply to all      \
299                                            regnode types.  For some, it's the \
300                                            character set of the regnode */
301 #define OPERAND(p)      (((struct regnode_string *)p)->string)
302 #define MASK(p)         ((char*)OPERAND(p))
303 #define STR_LEN(p)      (((struct regnode_string *)p)->str_len)
304 #define STRING(p)       (((struct regnode_string *)p)->string)
305 #define STR_SZ(l)       ((l + sizeof(regnode) - 1) / sizeof(regnode))
306 #define NODE_SZ_STR(p)  (STR_SZ(STR_LEN(p))+1)
307
308 #undef NODE_ALIGN
309 #undef ARG_LOC
310 #undef NEXTOPER
311 #undef PREVOPER
312
313 #define NODE_ALIGN(node)
314 #define ARG_LOC(p)      (((struct regnode_1 *)p)->arg1)
315 #define ARG1_LOC(p)     (((struct regnode_2 *)p)->arg1)
316 #define ARG2_LOC(p)     (((struct regnode_2 *)p)->arg2)
317 #define ARG2L_LOC(p)    (((struct regnode_2L *)p)->arg2)
318
319 #define NODE_STEP_REGNODE       1       /* sizeof(regnode)/sizeof(regnode) */
320 #define EXTRA_STEP_2ARGS        EXTRA_SIZE(struct regnode_2)
321
322 #define NODE_STEP_B     4
323
324 #define NEXTOPER(p)     ((p) + NODE_STEP_REGNODE)
325 #define PREVOPER(p)     ((p) - NODE_STEP_REGNODE)
326
327 #define FILL_ADVANCE_NODE(ptr, op) STMT_START { \
328     (ptr)->type = op;    (ptr)->next_off = 0;   (ptr)++; } STMT_END
329 #define FILL_ADVANCE_NODE_ARG(ptr, op, arg) STMT_START { \
330     ARG_SET(ptr, arg);  FILL_ADVANCE_NODE(ptr, op); (ptr) += 1; } STMT_END
331
332 #define REG_MAGIC 0234
333
334 #define SIZE_ONLY (RExC_emit == (regnode *) & RExC_emit_dummy)
335 #define PASS1 SIZE_ONLY
336 #define PASS2 (! SIZE_ONLY)
337
338 /* If the bitmap doesn't fully represent what this ANYOF node can match, the
339  * ARG is set to this special value (since 0, 1, ... are legal, but will never
340  * reach this high). */
341 #define ANYOF_NONBITMAP_EMPTY   ((U32) -1)
342
343 /* The information used to be stored as as combination of the ANYOF_UTF8 and
344  * ANYOF_NONBITMAP_NON_UTF8 bits in the flags field, but was moved out of there
345  * to free up a bit for other uses.  This tries to hide the change from
346  * existing code as much as possible.  Now, the data structure that goes in ARG
347  * is not allocated unless it is needed, and that is what is used to determine
348  * if there is something outside the bitmap.  The code now assumes that if
349  * that structure exists, that any UTF-8 encoded string should be tried against
350  * it, but a non-UTF8-encoded string will be tried only if the
351  * ANYOF_NONBITMAP_NON_UTF8 bit is also set. */
352 #define ANYOF_NONBITMAP(node)   (ARG(node) != ANYOF_NONBITMAP_EMPTY)
353
354 /* Flags for node->flags of ANYOF.  These are in short supply, with none
355  * currently available.  If more are needed, the ANYOF_LOCALE and
356  * ANYOF_POSIXL bits could be shared, making a space penalty for all locale
357  * nodes.  Also, the ABOVE_LATIN1_ALL bit could be freed up by resorting to
358  * creating a swash containing everything above 255.  This introduces a
359  * performance penalty.  Better would be to split it off into a separate node,
360  * which actually would improve performance a bit by allowing regexec.c to test
361  * for a UTF-8 character being above 255 without having to call a function nor
362  * calculate its code point value.  Several flags are not used in synthetic
363  * start class (SSC) nodes, so could be shared should new flags be needed for
364  * SSCs. */
365
366 /* regexec.c is expecting this to be in the low bit */
367 #define ANYOF_INVERT             0x01
368
369 /* For the SSC node only, which cannot be inverted, so is shared with that bit.
370  * This means "Does this SSC match an empty string?"  This is used only during
371  * regex compilation. */
372 #define ANYOF_EMPTY_STRING       ANYOF_INVERT
373
374 #define ANYOF_LOCALE             0x02       /* /l modifier */
375
376 /* The fold is calculated and stored in the bitmap where possible at compile
377  * time.  However under locale, the actual folding varies depending on
378  * what the locale is at the time of execution, so it has to be deferred until
379  * then */
380 #define ANYOF_LOC_FOLD           0x04
381
382 /* Set if this is a regnode_charclass_posixl vs a regnode_charclass.  This
383  * is used for runtime \d, \w, [:posix:], ..., which are used only in locale
384  * and the optimizer's synthetic start class.  Non-locale \d, etc are resolved
385  * at compile-time.  Could be shared with ANYOF_LOCALE, forcing all locale
386  * nodes to be large */
387 #define ANYOF_POSIXL             0x08
388 #define ANYOF_CLASS              ANYOF_POSIXL
389 #define ANYOF_LARGE              ANYOF_POSIXL
390
391 /* Should we raise a warning if matching against an above-Unicode code point?
392  * */
393 #define ANYOF_WARN_SUPER        0x10
394
395 /* Can match something outside the bitmap that isn't in utf8 */
396 #define ANYOF_NONBITMAP_NON_UTF8 0x20
397
398 /* Matches every code point 0x100 and above*/
399 #define ANYOF_ABOVE_LATIN1_ALL   0x40
400 #define ANYOF_UNICODE_ALL        ANYOF_ABOVE_LATIN1_ALL
401
402 /* Match all Latin1 characters that aren't ASCII when the target string is not
403  * in utf8. */
404 #define ANYOF_NON_UTF8_NON_ASCII_ALL 0x80
405
406 #define ANYOF_FLAGS_ALL         (0xff)
407
408 #define ANYOF_LOCALE_FLAGS (ANYOF_LOCALE                        \
409                            |ANYOF_LOC_FOLD                      \
410                            |ANYOF_POSIXL)
411
412 /* These are the flags that apply to both regular ANYOF nodes and synthetic
413  * start class nodes during construction of the SSC.  During finalization of
414  * the SSC, other of the flags could be added to it */
415 #define ANYOF_COMMON_FLAGS    (ANYOF_LOCALE_FLAGS | ANYOF_WARN_SUPER)
416
417 /* Character classes for node->classflags of ANYOF */
418 /* Should be synchronized with a table in regprop() */
419 /* 2n should be the normal one, paired with its complement at 2n+1 */
420
421 #define ANYOF_ALPHA    ((_CC_ALPHA) * 2)
422 #define ANYOF_NALPHA   ((ANYOF_ALPHA) + 1)
423 #define ANYOF_ALPHANUMERIC   ((_CC_ALPHANUMERIC) * 2)    /* [[:alnum:]] isalnum(3), utf8::IsAlnum */
424 #define ANYOF_NALPHANUMERIC  ((ANYOF_ALPHANUMERIC) + 1)
425 #define ANYOF_ASCII    ((_CC_ASCII) * 2)
426 #define ANYOF_NASCII   ((ANYOF_ASCII) + 1)
427 #define ANYOF_BLANK    ((_CC_BLANK) * 2)     /* GNU extension: space and tab: non-vertical space */
428 #define ANYOF_NBLANK   ((ANYOF_BLANK) + 1)
429 #define ANYOF_CASED    ((_CC_CASED) * 2)    /* Pseudo class for [:lower:] or
430                                                [:upper:] under /i */
431 #define ANYOF_NCASED   ((ANYOF_CASED) + 1)
432 #define ANYOF_CNTRL    ((_CC_CNTRL) * 2)
433 #define ANYOF_NCNTRL   ((ANYOF_CNTRL) + 1)
434 #define ANYOF_DIGIT    ((_CC_DIGIT) * 2)     /* \d */
435 #define ANYOF_NDIGIT   ((ANYOF_DIGIT) + 1)
436 #define ANYOF_GRAPH    ((_CC_GRAPH) * 2)
437 #define ANYOF_NGRAPH   ((ANYOF_GRAPH) + 1)
438 #define ANYOF_LOWER    ((_CC_LOWER) * 2)
439 #define ANYOF_NLOWER   ((ANYOF_LOWER) + 1)
440 #define ANYOF_PRINT    ((_CC_PRINT) * 2)
441 #define ANYOF_NPRINT   ((ANYOF_PRINT) + 1)
442 #define ANYOF_PSXSPC   ((_CC_PSXSPC) * 2)    /* POSIX space: \s plus the vertical tab */
443 #define ANYOF_NPSXSPC  ((ANYOF_PSXSPC) + 1)
444 #define ANYOF_PUNCT    ((_CC_PUNCT) * 2)
445 #define ANYOF_NPUNCT   ((ANYOF_PUNCT) + 1)
446 #define ANYOF_SPACE    ((_CC_SPACE) * 2)     /* \s */
447 #define ANYOF_NSPACE   ((ANYOF_SPACE) + 1)
448 #define ANYOF_UPPER    ((_CC_UPPER) * 2)
449 #define ANYOF_NUPPER   ((ANYOF_UPPER) + 1)
450 #define ANYOF_WORDCHAR ((_CC_WORDCHAR) * 2)  /* \w, PL_utf8_alnum, utf8::IsWord, ALNUM */
451 #define ANYOF_NWORDCHAR   ((ANYOF_WORDCHAR) + 1)
452 #define ANYOF_XDIGIT   ((_CC_XDIGIT) * 2)
453 #define ANYOF_NXDIGIT  ((ANYOF_XDIGIT) + 1)
454
455 /* pseudo classes below this, not stored in the class bitmap, but used as flags
456    during compilation of char classes */
457
458 #define ANYOF_VERTWS    ((_CC_VERTSPACE) * 2)
459 #define ANYOF_NVERTWS   ((ANYOF_VERTWS)+1)
460
461 /* It is best if this is the last one, as all above it are stored as bits in a
462  * bitmap, and it isn't part of that bitmap */
463 #if _CC_VERTSPACE != _HIGHEST_REGCOMP_DOT_H_SYNC
464 #   error Problem with handy.h _HIGHEST_REGCOMP_DOT_H_SYNC #define
465 #endif
466
467 #define ANYOF_POSIXL_MAX (ANYOF_VERTWS) /* So upper loop limit is written:
468                                          *       '< ANYOF_MAX'
469                                          * Hence doesn't include VERTWS, as that
470                                          * is a pseudo class */
471 #define ANYOF_MAX      ANYOF_POSIXL_MAX
472
473 #if (ANYOF_POSIXL_MAX > 32)   /* Must fit in 32-bit word */
474 #   error Problem with handy.h _CC_foo #defines
475 #endif
476
477 #define ANYOF_HORIZWS   ((ANYOF_POSIXL_MAX)+2) /* = (ANYOF_NVERTWS + 1) */
478 #define ANYOF_NHORIZWS  ((ANYOF_POSIXL_MAX)+3)
479
480 #define ANYOF_UNIPROP   ((ANYOF_POSIXL_MAX)+4)  /* Used to indicate a Unicode
481                                                    property: \p{} or \P{} */
482
483 /* Backward source code compatibility. */
484
485 #define ANYOF_ALNUML     ANYOF_ALNUM
486 #define ANYOF_NALNUML    ANYOF_NALNUM
487 #define ANYOF_SPACEL     ANYOF_SPACE
488 #define ANYOF_NSPACEL    ANYOF_NSPACE
489 #define ANYOF_ALNUM ANYOF_WORDCHAR
490 #define ANYOF_NALNUM ANYOF_NWORDCHAR
491
492 /* Utility macros for the bitmap and classes of ANYOF */
493
494 #define ANYOF_SIZE              (sizeof(struct regnode_charclass))
495 #define ANYOF_POSIXL_SIZE       (sizeof(regnode_charclass_posixl))
496 #define ANYOF_CLASS_SIZE        ANYOF_POSIXL_SIZE
497 #define ANYOF_POSIXL_FOLD_SIZE  (sizeof(regnode_charclass_posixl_fold))
498
499 #define ANYOF_FLAGS(p)          ((p)->flags)
500
501 #define ANYOF_BIT(c)            (1 << ((c) & 7))
502
503 #define ANYOF_POSIXL_SET(p, c)  (((regnode_charclass_posixl*) (p))->classflags |= (1U << (c)))
504 #define ANYOF_CLASS_SET(p, c)   ANYOF_POSIXL_SET((p), (c))
505
506 #define ANYOF_POSIXL_CLEAR(p, c) (((regnode_charclass_posixl*) (p))->classflags &= ~ (1U <<(c)))
507 #define ANYOF_CLASS_CLEAR(p, c) ANYOF_POSIXL_CLEAR((p), (c))
508
509 #define ANYOF_POSIXL_TEST(p, c) (((regnode_charclass_posixl*) (p))->classflags & (1U << (c)))
510 #define ANYOF_CLASS_TEST(p, c)  ANYOF_POSIXL_TEST((p), (c))
511
512 #define ANYOF_POSIXL_ZERO(ret)  STMT_START { ((regnode_charclass_posixl*) (ret))->classflags = 0; } STMT_END
513 #define ANYOF_CLASS_ZERO(ret)   ANYOF_POSIXL_ZERO(ret)
514
515 /* Shifts a bit to get, eg. 0x4000_0000, then subtracts 1 to get 0x3FFF_FFFF */
516 #define ANYOF_POSIXL_SETALL(ret) STMT_START { ((regnode_charclass_posixl*) (ret))->classflags = ((1U << ((ANYOF_POSIXL_MAX) - 1))) - 1; } STMT_END
517 #define ANYOF_CLASS_SETALL(ret) ANYOF_POSIXL_SETALL(ret)
518
519 #define ANYOF_POSIXL_TEST_ANY_SET(p)                               \
520         ((ANYOF_FLAGS(p) & ANYOF_POSIXL)                           \
521          && (((regnode_charclass_posixl*)(p))->classflags))
522 #define ANYOF_CLASS_TEST_ANY_SET(p) ANYOF_POSIXL_TEST_ANY_SET(p)
523
524 #define ANYOF_POSIXL_TEST_ALL_SET(p)                               \
525         ((ANYOF_FLAGS(p) & ANYOF_POSIXL)                           \
526          && ((regnode_charclass_posixl*) (p))->classflags == ((1U << ((ANYOF_POSIXL_MAX) - 1))) - 1)
527
528 #define ANYOF_POSIXL_OR(source, dest) STMT_START { (dest)->classflags |= (source)->classflags ; } STMT_END
529 #define ANYOF_CLASS_OR(source, dest) ANYOF_POSIXL_OR((source), (dest))
530
531 #define ANYOF_POSIXL_AND(source, dest) STMT_START { (dest)->classflags &= (source)->classflags ; } STMT_END
532
533 #define ANYOF_BITMAP_ZERO(ret)  Zero(((struct regnode_charclass*)(ret))->bitmap, ANYOF_BITMAP_SIZE, char)
534 #define ANYOF_BITMAP(p)         (((struct regnode_charclass*)(p))->bitmap)
535 #define ANYOF_BITMAP_BYTE(p, c) (ANYOF_BITMAP(p)[(((U8)(c)) >> 3) & 31])
536 #define ANYOF_BITMAP_SET(p, c)  (ANYOF_BITMAP_BYTE(p, c) |=  ANYOF_BIT(c))
537 #define ANYOF_BITMAP_CLEAR(p,c) (ANYOF_BITMAP_BYTE(p, c) &= ~ANYOF_BIT(c))
538 #define ANYOF_BITMAP_TEST(p, c) (ANYOF_BITMAP_BYTE(p, c) &   ANYOF_BIT(c))
539
540 #define ANYOF_BITMAP_SETALL(p)          \
541         memset (ANYOF_BITMAP(p), 255, ANYOF_BITMAP_SIZE)
542 #define ANYOF_BITMAP_CLEARALL(p)        \
543         Zero (ANYOF_BITMAP(p), ANYOF_BITMAP_SIZE)
544 /* Check that all 256 bits are all set.  Used in S_cl_is_anything()  */
545 #define ANYOF_BITMAP_TESTALLSET(p)      /* Assumes sizeof(p) == 32 */     \
546         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)
547
548 #define ANYOF_SKIP              ((ANYOF_SIZE - 1)/sizeof(regnode))
549 #define ANYOF_POSIXL_SKIP       ((ANYOF_POSIXL_SIZE - 1)/sizeof(regnode))
550 #define ANYOF_POSIXL_FOLD_SKIP  ((ANYOF_POSIXL_FOLD_SIZE - 1)/sizeof(regnode))
551 #define ANYOF_CLASS_SKIP        ANYOF_POSIXL_SKIP
552
553 #define ANYOF_UTF8_LOCALE_INVLIST(node) (((regnode_charclass_posixl_fold*) (node))->utf8_locale_list)
554
555 /*
556  * Utility definitions.
557  */
558 #ifndef CHARMASK
559 #  define UCHARAT(p)    ((int)*(const U8*)(p))
560 #else
561 #  define UCHARAT(p)    ((int)*(p)&CHARMASK)
562 #endif
563
564 #define EXTRA_SIZE(guy) ((sizeof(guy)-1)/sizeof(struct regnode))
565
566 #define REG_SEEN_ZERO_LEN       0x00000001
567 #define REG_SEEN_LOOKBEHIND     0x00000002
568 #define REG_SEEN_GPOS           0x00000004
569 /* spare */
570 #define REG_SEEN_CANY           0x00000010
571 #define REG_SEEN_SANY           REG_SEEN_CANY /* src bckwrd cmpt */
572 #define REG_SEEN_RECURSE        0x00000020
573 #define REG_TOP_LEVEL_BRANCHES  0x00000040
574 #define REG_SEEN_VERBARG        0x00000080
575 #define REG_SEEN_CUTGROUP       0x00000100
576 #define REG_SEEN_RUN_ON_COMMENT 0x00000200
577 #define REG_SEEN_UNFOLDED_MULTI 0x00000400
578 #define REG_SEEN_GOSTART        0x00000800
579
580 START_EXTERN_C
581
582 #ifdef PLUGGABLE_RE_EXTENSION
583 #include "re_nodes.h"
584 #else
585 #include "regnodes.h"
586 #endif
587
588 #ifndef PLUGGABLE_RE_EXTENSION
589 #ifndef DOINIT
590 EXTCONST regexp_engine PL_core_reg_engine;
591 #else /* DOINIT */
592 EXTCONST regexp_engine PL_core_reg_engine = { 
593         Perl_re_compile,
594         Perl_regexec_flags,
595         Perl_re_intuit_start,
596         Perl_re_intuit_string, 
597         Perl_regfree_internal,
598         Perl_reg_numbered_buff_fetch,
599         Perl_reg_numbered_buff_store,
600         Perl_reg_numbered_buff_length,
601         Perl_reg_named_buff,
602         Perl_reg_named_buff_iter,
603         Perl_reg_qr_package,
604 #if defined(USE_ITHREADS)        
605         Perl_regdupe_internal,
606 #endif        
607         Perl_re_op_compile
608 };
609 #endif /* DOINIT */
610 #endif /* PLUGGABLE_RE_EXTENSION */
611
612
613 END_EXTERN_C
614
615
616 /* .what is a character array with one character for each member of .data
617  * The character describes the function of the corresponding .data item:
618  *   a - AV for paren_name_list under DEBUGGING
619  *   f - start-class data for regstclass optimization
620  *   l - start op for literal (?{EVAL}) item
621  *   L - start op for literal (?{EVAL}) item, with separate CV (qr//)
622  *   r - pointer to an embedded code-containing qr, e.g. /ab$qr/
623  *   s - swash for Unicode-style character class, and the multicharacter
624  *       strings resulting from casefolding the single-character entries
625  *       in the character class
626  *   t - trie struct
627  *   u - trie struct's widecharmap (a HV, so can't share, must dup)
628  *       also used for revcharmap and words under DEBUGGING
629  *   T - aho-trie struct
630  *   S - sv for named capture lookup
631  * 20010712 mjd@plover.com
632  * (Remember to update re_dup() and pregfree() if you add any items.)
633  */
634 struct reg_data {
635     U32 count;
636     U8 *what;
637     void* data[1];
638 };
639
640 /* Code in S_to_utf8_substr() and S_to_byte_substr() in regexec.c accesses
641    anchored* and float* via array indexes 0 and 1.  */
642 #define anchored_substr substrs->data[0].substr
643 #define anchored_utf8 substrs->data[0].utf8_substr
644 #define anchored_offset substrs->data[0].min_offset
645 #define anchored_end_shift substrs->data[0].end_shift
646
647 #define float_substr substrs->data[1].substr
648 #define float_utf8 substrs->data[1].utf8_substr
649 #define float_min_offset substrs->data[1].min_offset
650 #define float_max_offset substrs->data[1].max_offset
651 #define float_end_shift substrs->data[1].end_shift
652
653 #define check_substr substrs->data[2].substr
654 #define check_utf8 substrs->data[2].utf8_substr
655 #define check_offset_min substrs->data[2].min_offset
656 #define check_offset_max substrs->data[2].max_offset
657 #define check_end_shift substrs->data[2].end_shift
658
659 #define RX_ANCHORED_SUBSTR(rx)  (ReANY(rx)->anchored_substr)
660 #define RX_ANCHORED_UTF8(rx)    (ReANY(rx)->anchored_utf8)
661 #define RX_FLOAT_SUBSTR(rx)     (ReANY(rx)->float_substr)
662 #define RX_FLOAT_UTF8(rx)       (ReANY(rx)->float_utf8)
663
664 /* trie related stuff */
665
666 /* a transition record for the state machine. the
667    check field determines which state "owns" the
668    transition. the char the transition is for is
669    determined by offset from the owning states base
670    field.  the next field determines which state
671    is to be transitioned to if any.
672 */
673 struct _reg_trie_trans {
674   U32 next;
675   U32 check;
676 };
677
678 /* a transition list element for the list based representation */
679 struct _reg_trie_trans_list_elem {
680     U16 forid;
681     U32 newstate;
682 };
683 typedef struct _reg_trie_trans_list_elem reg_trie_trans_le;
684
685 /* a state for compressed nodes. base is an offset
686   into an array of reg_trie_trans array. If wordnum is
687   nonzero the state is accepting. if base is zero then
688   the state has no children (and will be accepting)
689 */
690 struct _reg_trie_state {
691   U16 wordnum;
692   union {
693     U32                base;
694     reg_trie_trans_le* list;
695   } trans;
696 };
697
698 /* info per word; indexed by wordnum */
699 typedef struct {
700     U16  prev;  /* previous word in acceptance chain; eg in
701                  * zzz|abc|ab/ after matching the chars abc, the
702                  * accepted word is #2, and the previous accepted
703                  * word is #3 */
704     U32 len;    /* how many chars long is this word? */
705     U32 accept; /* accept state for this word */
706 } reg_trie_wordinfo;
707
708
709 typedef struct _reg_trie_state    reg_trie_state;
710 typedef struct _reg_trie_trans    reg_trie_trans;
711
712
713 /* anything in here that needs to be freed later
714    should be dealt with in pregfree.
715    refcount is first in both this and _reg_ac_data to allow a space
716    optimisation in Perl_regdupe.  */
717 struct _reg_trie_data {
718     U32             refcount;        /* number of times this trie is referenced */
719     U32             lasttrans;       /* last valid transition element */
720     U16             *charmap;        /* byte to charid lookup array */
721     reg_trie_state  *states;         /* state data */
722     reg_trie_trans  *trans;          /* array of transition elements */
723     char            *bitmap;         /* stclass bitmap */
724     U16             *jump;           /* optional 1 indexed array of offsets before tail 
725                                         for the node following a given word. */
726     reg_trie_wordinfo *wordinfo;     /* array of info per word */
727     U16             uniquecharcount; /* unique chars in trie (width of trans table) */
728     U32             startstate;      /* initial state - used for common prefix optimisation */
729     STRLEN          minlen;          /* minimum length of words in trie - build/opt only? */
730     STRLEN          maxlen;          /* maximum length of words in trie - build/opt only? */
731     U32             prefixlen;       /* #chars in common prefix */
732     U32             statecount;      /* Build only - number of states in the states array 
733                                         (including the unused zero state) */
734     U32             wordcount;       /* Build only */
735 #ifdef DEBUGGING
736     STRLEN          charcount;       /* Build only */
737 #endif
738 };
739 /* There is one (3 under DEBUGGING) pointers that logically belong in this
740    structure, but are held outside as they need duplication on thread cloning,
741    whereas the rest of the structure can be read only:
742     HV              *widecharmap;    code points > 255 to charid
743 #ifdef DEBUGGING
744     AV              *words;          Array of words contained in trie, for dumping
745     AV              *revcharmap;     Map of each charid back to its character representation
746 #endif
747 */
748
749 #define TRIE_WORDS_OFFSET 2
750
751 typedef struct _reg_trie_data reg_trie_data;
752
753 /* refcount is first in both this and _reg_trie_data to allow a space
754    optimisation in Perl_regdupe.  */
755 struct _reg_ac_data {
756     U32              refcount;
757     U32              trie;
758     U32              *fail;
759     reg_trie_state   *states;
760 };
761 typedef struct _reg_ac_data reg_ac_data;
762
763 /* ANY_BIT doesn't use the structure, so we can borrow it here.
764    This is simpler than refactoring all of it as wed end up with
765    three different sets... */
766
767 #define TRIE_BITMAP(p)          (((reg_trie_data *)(p))->bitmap)
768 #define TRIE_BITMAP_BYTE(p, c)  (TRIE_BITMAP(p)[(((U8)(c)) >> 3) & 31])
769 #define TRIE_BITMAP_SET(p, c)   (TRIE_BITMAP_BYTE(p, c) |=  ANYOF_BIT((U8)c))
770 #define TRIE_BITMAP_CLEAR(p,c)  (TRIE_BITMAP_BYTE(p, c) &= ~ANYOF_BIT((U8)c))
771 #define TRIE_BITMAP_TEST(p, c)  (TRIE_BITMAP_BYTE(p, c) &   ANYOF_BIT((U8)c))
772
773 #define IS_ANYOF_TRIE(op) ((op)==TRIEC || (op)==AHOCORASICKC)
774 #define IS_TRIE_AC(op) ((op)>=AHOCORASICK)
775
776
777 #define BITMAP_BYTE(p, c)       (((U8*)p)[(((U8)(c)) >> 3) & 31])
778 #define BITMAP_TEST(p, c)       (BITMAP_BYTE(p, c) &   ANYOF_BIT((U8)c))
779
780 /* these defines assume uniquecharcount is the correct variable, and state may be evaluated twice */
781 #define TRIE_NODENUM(state) (((state)-1)/(trie->uniquecharcount)+1)
782 #define SAFE_TRIE_NODENUM(state) ((state) ? (((state)-1)/(trie->uniquecharcount)+1) : (state))
783 #define TRIE_NODEIDX(state) ((state) ? (((state)-1)*(trie->uniquecharcount)+1) : (state))
784
785 #ifdef DEBUGGING
786 #define TRIE_CHARCOUNT(trie) ((trie)->charcount)
787 #else
788 #define TRIE_CHARCOUNT(trie) (trie_charcount)
789 #endif
790
791 #define RE_TRIE_MAXBUF_INIT 65536
792 #define RE_TRIE_MAXBUF_NAME "\022E_TRIE_MAXBUF"
793 #define RE_DEBUG_FLAGS "\022E_DEBUG_FLAGS"
794
795 /*
796
797 RE_DEBUG_FLAGS is used to control what debug output is emitted
798 its divided into three groups of options, some of which interact.
799 The three groups are: Compile, Execute, Extra. There is room for a
800 further group, as currently only the low three bytes are used.
801
802     Compile Options:
803     
804     PARSE
805     PEEP
806     TRIE
807     PROGRAM
808     OFFSETS
809
810     Execute Options:
811
812     INTUIT
813     MATCH
814     TRIE
815
816     Extra Options
817
818     TRIE
819     OFFSETS
820
821 If you modify any of these make sure you make corresponding changes to
822 re.pm, especially to the documentation.
823
824 */
825
826
827 /* Compile */
828 #define RE_DEBUG_COMPILE_MASK      0x0000FF
829 #define RE_DEBUG_COMPILE_PARSE     0x000001
830 #define RE_DEBUG_COMPILE_OPTIMISE  0x000002
831 #define RE_DEBUG_COMPILE_TRIE      0x000004
832 #define RE_DEBUG_COMPILE_DUMP      0x000008
833 #define RE_DEBUG_COMPILE_FLAGS     0x000010
834
835 /* Execute */
836 #define RE_DEBUG_EXECUTE_MASK      0x00FF00
837 #define RE_DEBUG_EXECUTE_INTUIT    0x000100
838 #define RE_DEBUG_EXECUTE_MATCH     0x000200
839 #define RE_DEBUG_EXECUTE_TRIE      0x000400
840
841 /* Extra */
842 #define RE_DEBUG_EXTRA_MASK        0xFF0000
843 #define RE_DEBUG_EXTRA_TRIE        0x010000
844 #define RE_DEBUG_EXTRA_OFFSETS     0x020000
845 #define RE_DEBUG_EXTRA_OFFDEBUG    0x040000
846 #define RE_DEBUG_EXTRA_STATE       0x080000
847 #define RE_DEBUG_EXTRA_OPTIMISE    0x100000
848 #define RE_DEBUG_EXTRA_BUFFERS     0x400000
849 #define RE_DEBUG_EXTRA_GPOS        0x800000
850 /* combined */
851 #define RE_DEBUG_EXTRA_STACK       0x280000
852
853 #define RE_DEBUG_FLAG(x) (re_debug_flags & x)
854 /* Compile */
855 #define DEBUG_COMPILE_r(x) DEBUG_r( \
856     if (re_debug_flags & RE_DEBUG_COMPILE_MASK) x  )
857 #define DEBUG_PARSE_r(x) DEBUG_r( \
858     if (re_debug_flags & RE_DEBUG_COMPILE_PARSE) x  )
859 #define DEBUG_OPTIMISE_r(x) DEBUG_r( \
860     if (re_debug_flags & RE_DEBUG_COMPILE_OPTIMISE) x  )
861 #define DEBUG_PARSE_r(x) DEBUG_r( \
862     if (re_debug_flags & RE_DEBUG_COMPILE_PARSE) x  )
863 #define DEBUG_DUMP_r(x) DEBUG_r( \
864     if (re_debug_flags & RE_DEBUG_COMPILE_DUMP) x  )
865 #define DEBUG_TRIE_COMPILE_r(x) DEBUG_r( \
866     if (re_debug_flags & RE_DEBUG_COMPILE_TRIE) x )
867 #define DEBUG_FLAGS_r(x) DEBUG_r( \
868     if (re_debug_flags & RE_DEBUG_COMPILE_FLAGS) x )
869 /* Execute */
870 #define DEBUG_EXECUTE_r(x) DEBUG_r( \
871     if (re_debug_flags & RE_DEBUG_EXECUTE_MASK) x  )
872 #define DEBUG_INTUIT_r(x) DEBUG_r( \
873     if (re_debug_flags & RE_DEBUG_EXECUTE_INTUIT) x  )
874 #define DEBUG_MATCH_r(x) DEBUG_r( \
875     if (re_debug_flags & RE_DEBUG_EXECUTE_MATCH) x  )
876 #define DEBUG_TRIE_EXECUTE_r(x) DEBUG_r( \
877     if (re_debug_flags & RE_DEBUG_EXECUTE_TRIE) x )
878
879 /* Extra */
880 #define DEBUG_EXTRA_r(x) DEBUG_r( \
881     if (re_debug_flags & RE_DEBUG_EXTRA_MASK) x  )
882 #define DEBUG_OFFSETS_r(x) DEBUG_r( \
883     if (re_debug_flags & RE_DEBUG_EXTRA_OFFSETS) x  )
884 #define DEBUG_STATE_r(x) DEBUG_r( \
885     if (re_debug_flags & RE_DEBUG_EXTRA_STATE) x )
886 #define DEBUG_STACK_r(x) DEBUG_r( \
887     if (re_debug_flags & RE_DEBUG_EXTRA_STACK) x )
888 #define DEBUG_BUFFERS_r(x) DEBUG_r( \
889     if (re_debug_flags & RE_DEBUG_EXTRA_BUFFERS) x )
890
891 #define DEBUG_OPTIMISE_MORE_r(x) DEBUG_r( \
892     if ((RE_DEBUG_EXTRA_OPTIMISE|RE_DEBUG_COMPILE_OPTIMISE) == \
893          (re_debug_flags & (RE_DEBUG_EXTRA_OPTIMISE|RE_DEBUG_COMPILE_OPTIMISE)) ) x )
894 #define MJD_OFFSET_DEBUG(x) DEBUG_r( \
895     if (re_debug_flags & RE_DEBUG_EXTRA_OFFDEBUG) \
896         Perl_warn_nocontext x )
897 #define DEBUG_TRIE_COMPILE_MORE_r(x) DEBUG_TRIE_COMPILE_r( \
898     if (re_debug_flags & RE_DEBUG_EXTRA_TRIE) x )
899 #define DEBUG_TRIE_EXECUTE_MORE_r(x) DEBUG_TRIE_EXECUTE_r( \
900     if (re_debug_flags & RE_DEBUG_EXTRA_TRIE) x )
901
902 #define DEBUG_TRIE_r(x) DEBUG_r( \
903     if (re_debug_flags & (RE_DEBUG_COMPILE_TRIE \
904         | RE_DEBUG_EXECUTE_TRIE )) x )
905 #define DEBUG_GPOS_r(x) DEBUG_r( \
906     if (re_debug_flags & RE_DEBUG_EXTRA_GPOS) x )
907
908 /* initialization */
909 /* get_sv() can return NULL during global destruction. */
910 #define GET_RE_DEBUG_FLAGS DEBUG_r({ \
911         SV * re_debug_flags_sv = NULL; \
912         re_debug_flags_sv = get_sv(RE_DEBUG_FLAGS, 1); \
913         if (re_debug_flags_sv) { \
914             if (!SvIOK(re_debug_flags_sv)) \
915                 sv_setuv(re_debug_flags_sv, RE_DEBUG_COMPILE_DUMP | RE_DEBUG_EXECUTE_MASK ); \
916             re_debug_flags=SvIV(re_debug_flags_sv); \
917         }\
918 })
919
920 #ifdef DEBUGGING
921
922 #define GET_RE_DEBUG_FLAGS_DECL VOL IV re_debug_flags  = 0; \
923         PERL_UNUSED_VAR(re_debug_flags); GET_RE_DEBUG_FLAGS;
924
925 #define RE_PV_COLOR_DECL(rpv,rlen,isuni,dsv,pv,l,m,c1,c2) \
926     const char * const rpv =                          \
927         pv_pretty((dsv), (pv), (l), (m), \
928             PL_colors[(c1)],PL_colors[(c2)], \
929             PERL_PV_ESCAPE_RE|PERL_PV_ESCAPE_NONASCII |((isuni) ? PERL_PV_ESCAPE_UNI : 0) );         \
930     const int rlen = SvCUR(dsv)
931
932 #define RE_SV_ESCAPE(rpv,isuni,dsv,sv,m) \
933     const char * const rpv =                          \
934         pv_pretty((dsv), (SvPV_nolen_const(sv)), (SvCUR(sv)), (m), \
935             PL_colors[(c1)],PL_colors[(c2)], \
936             PERL_PV_ESCAPE_RE|PERL_PV_ESCAPE_NONASCII |((isuni) ? PERL_PV_ESCAPE_UNI : 0) )
937
938 #define RE_PV_QUOTED_DECL(rpv,isuni,dsv,pv,l,m)                    \
939     const char * const rpv =                                       \
940         pv_pretty((dsv), (pv), (l), (m), \
941             PL_colors[0], PL_colors[1], \
942             ( PERL_PV_PRETTY_QUOTE | PERL_PV_ESCAPE_RE | PERL_PV_ESCAPE_NONASCII | PERL_PV_PRETTY_ELLIPSES | \
943               ((isuni) ? PERL_PV_ESCAPE_UNI : 0))                  \
944         )
945
946 #define RE_SV_DUMPLEN(ItEm) (SvCUR(ItEm) - (SvTAIL(ItEm)!=0))
947 #define RE_SV_TAIL(ItEm) (SvTAIL(ItEm) ? "$" : "")
948     
949 #else /* if not DEBUGGING */
950
951 #define GET_RE_DEBUG_FLAGS_DECL
952 #define RE_PV_COLOR_DECL(rpv,rlen,isuni,dsv,pv,l,m,c1,c2)
953 #define RE_SV_ESCAPE(rpv,isuni,dsv,sv,m)
954 #define RE_PV_QUOTED_DECL(rpv,isuni,dsv,pv,l,m)
955 #define RE_SV_DUMPLEN(ItEm)
956 #define RE_SV_TAIL(ItEm)
957
958 #endif /* DEBUG RELATED DEFINES */
959
960 /*
961  * Local variables:
962  * c-indentation-style: bsd
963  * c-basic-offset: 4
964  * indent-tabs-mode: nil
965  * End:
966  *
967  * ex: set ts=8 sts=4 sw=4 et:
968  */