regcomp.h

   1 /*    regcomp.h
   2  */
   3
   4 typedef OP OP_4tree;                    /* Will be redefined later. */
   5
   6 /*
   7  * The "internal use only" fields in regexp.h are present to pass info from
   8  * compile to execute that permits the execute phase to run lots faster on
   9  * simple cases.  They are:
  10  *
  11  * regstart     sv that must begin a match; Nullch if none obvious
  12  * reganch      is the match anchored (at beginning-of-line only)?
  13  * regmust      string (pointer into program) that match must include, or NULL
  14  *  [regmust changed to SV* for bminstr()--law]
  15  * regmlen      length of regmust string
  16  *  [regmlen not used currently]
  17  *
  18  * Regstart and reganch permit very fast decisions on suitable starting points
  19  * for a match, cutting down the work a lot.  Regmust permits fast rejection
  20  * of lines that cannot possibly match.  The regmust tests are costly enough
  21  * that pregcomp() supplies a regmust only if the r.e. contains something
  22  * potentially expensive (at present, the only such thing detected is * or +
  23  * at the start of the r.e., which can involve a lot of backup).  Regmlen is
  24  * supplied because the test in pregexec() needs it and pregcomp() is computing
  25  * it anyway.
  26  * [regmust is now supplied always.  The tests that use regmust have a
  27  * heuristic that disables the test if it usually matches.]
  28  *
  29  * [In fact, we now use regmust in many cases to locate where the search
  30  * starts in the string, so if regback is >= 0, the regmust search is never
  31  * wasted effort.  The regback variable says how many characters back from
  32  * where regmust matched is the earliest possible start of the match.
  33  * For instance, /[a-z].foo/ has a regmust of 'foo' and a regback of 2.]
  34  */
  35
  36 /*
  37  * Structure for regexp "program".  This is essentially a linear encoding
  38  * of a nondeterministic finite-state machine (aka syntax charts or
  39  * "railroad normal form" in parsing technology).  Each node is an opcode
  40  * plus a "next" pointer, possibly plus an operand.  "Next" pointers of
  41  * all nodes except BRANCH implement concatenation; a "next" pointer with
  42  * a BRANCH on both ends of it is connecting two alternatives.  (Here we
  43  * have one of the subtle syntax dependencies:  an individual BRANCH (as
  44  * opposed to a collection of them) is never concatenated with anything
  45  * because of operator precedence.)  The operand of some types of node is
  46  * a literal string; for others, it is a node leading into a sub-FSM.  In
  47  * particular, the operand of a BRANCH node is the first node of the branch.
  48  * (NB this is *not* a tree structure:  the tail of the branch connects
  49  * to the thing following the set of BRANCHes.)  The opcodes are:
  50  */
  51
  52 /*
  53  * A node is one char of opcode followed by two chars of "next" pointer.
  54  * "Next" pointers are stored as two 8-bit pieces, high order first.  The
  55  * value is a positive offset from the opcode of the node containing it.
  56  * An operand, if any, simply follows the node.  (Note that much of the
  57  * code generation knows about this implicit relationship.)
  58  *
  59  * Using two bytes for the "next" pointer is vast overkill for most things,
  60  * but allows patterns to get big without disasters.
  61  *
  62  * [The "next" pointer is always aligned on an even
  63  * boundary, and reads the offset directly as a short.  Also, there is no
  64  * special test to reverse the sign of BACK pointers since the offset is
  65  * stored negative.]
  66  */
  67
  68 struct regnode_string {
  69     U8  str_len;
  70     U8  type;
  71     U16 next_off;
  72     char string[1];
  73 };
  74
  75 struct regnode_1 {
  76     U8  flags;
  77     U8  type;
  78     U16 next_off;
  79     U32 arg1;
  80 };
  81
  82 struct regnode_2 {
  83     U8  flags;
  84     U8  type;
  85     U16 next_off;
  86     U16 arg1;
  87     U16 arg2;
  88 };
  89
  90 /* XXX fix this description.
  91    Impose a limit of REG_INFTY on various pattern matching operations
  92    to limit stack growth and to avoid "infinite" recursions.
  93 */
  94 /* The default size for REG_INFTY is I16_MAX, which is the same as
  95    SHORT_MAX (see perl.h).  Unfortunately I16 isn't necessarily 16 bits
  96    (see handy.h).  On the Cray C90, sizeof(short)==4 and hence I16_MAX is
  97    ((1<<31)-1), while on the Cray T90, sizeof(short)==8 and I16_MAX is
  98    ((1<<63)-1).  To limit stack growth to reasonable sizes, supply a
  99    smaller default.
 100         --Andy Dougherty  11 June 1998
 101 */
 102 #if SHORTSIZE > 2
 103 #  ifndef REG_INFTY
 104 #    define REG_INFTY ((1<<15)-1)
 105 #  endif
 106 #endif
 107
 108 #ifndef REG_INFTY
 109 #  define REG_INFTY I16_MAX
 110 #endif
 111
 112 #define ARG_VALUE(arg) (arg)
 113 #define ARG__SET(arg,val) ((arg) = (val))
 114
 115 #define ARG(p) ARG_VALUE(ARG_LOC(p))
 116 #define ARG1(p) ARG_VALUE(ARG1_LOC(p))
 117 #define ARG2(p) ARG_VALUE(ARG2_LOC(p))
 118 #define ARG_SET(p, val) ARG__SET(ARG_LOC(p), (val))
 119 #define ARG1_SET(p, val) ARG__SET(ARG1_LOC(p), (val))
 120 #define ARG2_SET(p, val) ARG__SET(ARG2_LOC(p), (val))
 121
 122 #ifndef lint
 123 #  define NEXT_OFF(p) ((p)->next_off)
 124 #  define NODE_ALIGN(node)
 125 #  define NODE_ALIGN_FILL(node) ((node)->flags = 0xde) /* deadbeef */
 126 #else /* lint */
 127 #  define NEXT_OFF(p) 0
 128 #  define NODE_ALIGN(node)
 129 #  define NODE_ALIGN_FILL(node)
 130 #endif /* lint */
 131
 132 #define SIZE_ALIGN NODE_ALIGN
 133
 134 #define OP(p)           ((p)->type)
 135 #define OPERAND(p)      (((struct regnode_string *)p)->string)
 136 #define MASK(p)         ((char*)OPERAND(p))
 137 #define STR_LEN(p)      (((struct regnode_string *)p)->str_len)
 138 #define STRING(p)       (((struct regnode_string *)p)->string)
 139 #define STR_SZ(l)       ((l + sizeof(regnode) - 1) / sizeof(regnode))
 140 #define NODE_SZ_STR(p)  (STR_SZ(STR_LEN(p))+1)
 141
 142 #define NODE_ALIGN(node)
 143 #define ARG_LOC(p)      (((struct regnode_1 *)p)->arg1)
 144 #define ARG1_LOC(p)     (((struct regnode_2 *)p)->arg1)
 145 #define ARG2_LOC(p)     (((struct regnode_2 *)p)->arg2)
 146 #define NODE_STEP_REGNODE       1       /* sizeof(regnode)/sizeof(regnode) */
 147 #define EXTRA_STEP_2ARGS        EXTRA_SIZE(struct regnode_2)
 148
 149 #define NODE_STEP_B     4
 150
 151 #define NEXTOPER(p)     ((p) + NODE_STEP_REGNODE)
 152 #define PREVOPER(p)     ((p) - NODE_STEP_REGNODE)
 153
 154 #define FILL_ADVANCE_NODE(ptr, op) STMT_START { \
 155     (ptr)->type = op;    (ptr)->next_off = 0;   (ptr)++; } STMT_END
 156 #define FILL_ADVANCE_NODE_ARG(ptr, op, arg) STMT_START { \
 157     ARG_SET(ptr, arg);  FILL_ADVANCE_NODE(ptr, op); (ptr) += 1; } STMT_END
 158
 159 #define REG_MAGIC 0234
 160
 161 #define SIZE_ONLY (PL_regcode == &PL_regdummy)
 162
 163 /* Flags for first parameter byte [0] of ANYOF */
 164
 165 #define ANYOF_CLASS     0x08
 166 #define ANYOF_INVERT    0x04
 167 #define ANYOF_FOLD      0x02
 168 #define ANYOF_LOCALE    0x01
 169
 170 /* Character classes for bytes [1..4] of ANYOF */
 171
 172 #define ANYOF_ALNUM      0      /* \w, utf8::IsWord, isALNUM() */
 173 #define ANYOF_NALNUM     1
 174 #define ANYOF_SPACE      2
 175 #define ANYOF_NSPACE     3
 176 #define ANYOF_DIGIT      4
 177 #define ANYOF_NDIGIT     5
 178 #define ANYOF_ALNUMC     6      /* isalnum(3), utf8::IsAlnum, isALNUMC() */
 179 #define ANYOF_NALNUMC    7
 180 #define ANYOF_ALPHA      8
 181 #define ANYOF_NALPHA     9
 182 #define ANYOF_ASCII     10
 183 #define ANYOF_NASCII    11
 184 #define ANYOF_CNTRL     12
 185 #define ANYOF_NCNTRL    13
 186 #define ANYOF_GRAPH     14
 187 #define ANYOF_NGRAPH    15
 188 #define ANYOF_LOWER     16
 189 #define ANYOF_NLOWER    17
 190 #define ANYOF_PRINT     18
 191 #define ANYOF_NPRINT    19
 192 #define ANYOF_PUNCT     20
 193 #define ANYOF_NPUNCT    21
 194 #define ANYOF_UPPER     22
 195 #define ANYOF_NUPPER    23
 196 #define ANYOF_XDIGIT    24
 197 #define ANYOF_NXDIGIT   25
 198
 199 #define ANYOF_MAX       31
 200
 201 /* Backward source code compatibility. */
 202
 203 #define ANYOF_ALNUML     ANYOF_ALNUM
 204 #define ANYOF_NALNUML    ANYOF_NALNUM
 205 #define ANYOF_SPACEL     ANYOF_SPACE
 206 #define ANYOF_NSPACEL    ANYOF_NSPACE
 207
 208 /* Utility macros for the bitmap and classes of ANYOF */
 209
 210 #define ANYOF_OPND_SIZE          1
 211 #define ANYOF_CLASS_SIZE         4
 212 #define ANYOF_BITMAP_SIZE       32      /* 256 b/(8 b/B) */
 213 #define ANYOF_SIZE      (ANYOF_OPND_SIZE+ANYOF_CLASS_SIZE+ANYOF_BITMAP_SIZE)
 214
 215 #define ANYOF_FLAGS(p)          ((p)[0])
 216 #define ANYOF_FLAGS_ALL         0xff
 217
 218 #define ANYOF_BIT(c)            (1 << ((c) & 7))
 219
 220 #define ANYOF_CLASS_OFFSET      ANYOF_OPND_SIZE
 221 #define ANYOF_CLASS_BYTE(p, c)  ((p)[ANYOF_CLASS_OFFSET + (((c) >> 3) & 3)])
 222 #define ANYOF_CLASS_SET(p, c)   (ANYOF_CLASS_BYTE(p, c) |=  ANYOF_BIT(c))
 223 #define ANYOF_CLASS_CLEAR(p, c) (ANYOF_CLASS_BYTE(p, c) &= ~ANYOF_BIT(c))
 224 #define ANYOF_CLASS_TEST(p, c)  (ANYOF_CLASS_BYTE(p, c) &   ANYOF_BIT(c))
 225
 226 #define ANYOF_BITMAP_OFFSET     (ANYOF_CLASS_OFFSET+ANYOF_CLASS_SIZE)
 227 #define ANYOF_BITMAP_BYTE(p, c) ((p)[ANYOF_BITMAP_OFFSET + (((c) >> 3) & 31)])
 228 #define ANYOF_BITMAP_SET(p, c)  (ANYOF_BITMAP_BYTE(p, c) |=  ANYOF_BIT(c))
 229 #define ANYOF_BITMAP_CLEAR(p,c) (ANYOF_BITMAP_BYTE(p, c) &= ~ANYOF_BIT(c))
 230 #define ANYOF_BITMAP_TEST(p, c) (ANYOF_BITMAP_BYTE(p, c) &   ANYOF_BIT(c))
 231
 232 #define ANY_SKIP ((ANYOF_SIZE - 1)/sizeof(regnode) + 1)
 233
 234 /*
 235  * Utility definitions.
 236  */
 237 #ifndef lint
 238 #ifndef CHARMASK
 239 #define UCHARAT(p)      ((int)*(U8*)(p))
 240 #else
 241 #define UCHARAT(p)      ((int)*(p)&CHARMASK)
 242 #endif
 243 #else /* lint */
 244 #define UCHARAT(p)      PL_regdummy
 245 #endif /* lint */
 246
 247 #define FAIL(m) \
 248     STMT_START {                                                        \
 249         if (!SIZE_ONLY)                                                 \
 250             SAVEDESTRUCTOR(clear_re,(void*)PL_regcomp_rx);              \
 251         Perl_croak(aTHX_ "/%.127s/: %s",  PL_regprecomp,m);             \
 252     } STMT_END
 253
 254 #define FAIL2(pat,m) \
 255     STMT_START {                                                        \
 256         if (!SIZE_ONLY)                                                 \
 257             SAVEDESTRUCTOR(clear_re,(void*)PL_regcomp_rx);              \
 258         S_re_croak2(aTHX_ "/%.127s/: ",pat,PL_regprecomp,m);            \
 259     } STMT_END
 260
 261 #define EXTRA_SIZE(guy) ((sizeof(guy)-1)/sizeof(struct regnode))
 262
 263 #define REG_SEEN_ZERO_LEN       1
 264 #define REG_SEEN_LOOKBEHIND     2
 265 #define REG_SEEN_GPOS           4
 266 #define REG_SEEN_EVAL           8
 267
 268 START_EXTERN_C
 269
 270 #include "regnodes.h"
 271
 272 /* The following have no fixed length. U8 so we can do strchr() on it. */
 273 #ifndef DOINIT
 274 EXTCONST U8 PL_varies[];
 275 #else
 276 EXTCONST U8 PL_varies[] = {
 277     BRANCH, BACK, STAR, PLUS, CURLY, CURLYX, REF, REFF, REFFL,
 278     WHILEM, CURLYM, CURLYN, BRANCHJ, IFTHEN, SUSPEND, CLUMP, 0
 279 };
 280 #endif
 281
 282 /* The following always have a length of 1. U8 we can do strchr() on it. */
 283 /* (Note that length 1 means "one character" under UTF8, not "one octet".) */
 284 #ifndef DOINIT
 285 EXTCONST U8 PL_simple[];
 286 #else
 287 EXTCONST U8 PL_simple[] = {
 288     REG_ANY, ANYUTF8, SANY, SANYUTF8, ANYOF, ANYOFUTF8,
 289     ALNUM, ALNUMUTF8, ALNUML, ALNUMLUTF8,
 290     NALNUM, NALNUMUTF8, NALNUML, NALNUMLUTF8,
 291     SPACE, SPACEUTF8, SPACEL, SPACELUTF8,
 292     NSPACE, NSPACEUTF8, NSPACEL, NSPACELUTF8,
 293     DIGIT, DIGITUTF8, NDIGIT, NDIGITUTF8, 0
 294 };
 295 #endif
 296
 297 END_EXTERN_C
 298
 299 typedef struct re_scream_pos_data_s
 300 {
 301     char **scream_olds;         /* match pos */
 302     I32 *scream_pos;            /* Internal iterator of scream. */
 303 } re_scream_pos_data;
 304
 305 struct reg_data {
 306     U32 count;
 307     U8 *what;
 308     void* data[1];
 309 };
 310
 311 struct reg_substr_datum {
 312     I32 min_offset;
 313     I32 max_offset;
 314     SV *substr;
 315 };
 316
 317 struct reg_substr_data {
 318     struct reg_substr_datum data[3];    /* Actual array */
 319 };
 320
 321 #define anchored_substr substrs->data[0].substr
 322 #define anchored_offset substrs->data[0].min_offset
 323 #define float_substr substrs->data[1].substr
 324 #define float_min_offset substrs->data[1].min_offset
 325 #define float_max_offset substrs->data[1].max_offset
 326 #define check_substr substrs->data[2].substr
 327 #define check_offset_min substrs->data[2].min_offset
 328 #define check_offset_max substrs->data[2].max_offset