regexp.h

   1 /*    regexp.h
   2  *
   3  *    Copyright (C) 1993, 1994, 1996, 1997, 1999, 2000, 2001, 2003,
   4  *    2005, 2006 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
  11 /*
  12  * Definitions etc. for regexp(3) routines.
  13  *
  14  * Caveat:  this is V8 regexp(3) [actually, a reimplementation thereof],
  15  * not the System V one.
  16  */
  17 #ifndef PLUGGABLE_RE_EXTENSION
  18 /* we don't want to include this stuff if we are inside of
  19    an external regex engine based on the core one - like re 'debug'*/
  20
  21 struct regnode {
  22     U8  flags;
  23     U8  type;
  24     U16 next_off;
  25 };
  26
  27 typedef struct regnode regnode;
  28
  29 struct reg_substr_data;
  30
  31 struct reg_data;
  32
  33 struct regexp_engine;
  34 struct regexp;
  35
  36 struct reg_substr_datum {
  37     I32 min_offset;
  38     I32 max_offset;
  39     SV *substr;         /* non-utf8 variant */
  40     SV *utf8_substr;    /* utf8 variant */
  41     I32 end_shift;
  42 };
  43 struct reg_substr_data {
  44     struct reg_substr_datum data[3];    /* Actual array */
  45 };
  46
  47 #ifdef PERL_OLD_COPY_ON_WRITE
  48 #define SV_SAVED_COPY   SV *saved_copy; /* If non-NULL, SV which is COW from original */
  49 #else
  50 #define SV_SAVED_COPY
  51 #endif
  52
  53 typedef struct regexp_paren_pair {
  54     I32 start;
  55     I32 end;
  56 } regexp_paren_pair;
  57
  58 /*
  59   The regexp/REGEXP struct, see L<perlreapi> for further documentation
  60   on the individual fields. The struct is ordered so that the most
  61   commonly used fields are placed at the start.
  62
  63   Any patch that adds items to this struct will need to include
  64   changes to F<sv.c> (C<Perl_re_dup()>) and F<regcomp.c>
  65   (C<pregfree()>). This involves freeing or cloning items in the
  66   regexp's data array based on the data item's type.
  67 */
  68
  69 typedef struct regexp {
  70         /* what engine created this regexp? */
  71         const struct regexp_engine* engine;
  72         struct regexp* mother_re; /* what re is this a lightweight copy of? */
  73
  74         /* Information about the match that the perl core uses to manage things */
  75         U32 extflags;           /* Flags used both externally and internally */
  76         I32 minlen;             /* mininum possible length of string to match */
  77         I32 minlenret;          /* mininum possible length of $& */
  78         U32 gofs;               /* chars left of pos that we search from */
  79         struct reg_substr_data *substrs; /* substring data about strings that must appear
  80                                    in the final match, used for optimisations */
  81         U32 nparens;            /* number of capture buffers */
  82
  83         /* private engine specific data */
  84         U32 intflags;           /* Engine Specific Internal flags */
  85         void *pprivate;         /* Data private to the regex engine which
  86                                    created this object. */
  87
  88         /* Data about the last/current match. These are modified during matching*/
  89         U32 lastparen;          /* last open paren matched */
  90         U32 lastcloseparen;     /* last close paren matched */
  91         regexp_paren_pair *swap;  /* Swap copy of *offs */
  92         regexp_paren_pair *offs;  /* Array of offsets for (@-) and (@+) */
  93
  94         char *subbeg;           /* saved or original string
  95                                    so \digit works forever. */
  96         SV_SAVED_COPY           /* If non-NULL, SV which is COW from original */
  97         I32 sublen;             /* Length of string pointed by subbeg */
  98
  99
 100         /* Information about the match that isn't often used */
 101         I32 prelen;             /* length of precomp */
 102         const char *precomp;    /* pre-compilation regular expression */
 103         /* wrapped can't be const char*, as it is returned by sv_2pv_flags */
 104         char *wrapped;          /* wrapped version of the pattern */
 105         I32 wraplen;            /* length of wrapped */
 106         I32 seen_evals;         /* number of eval groups in the pattern - for security checks */
 107         HV *paren_names;        /* Optional hash of paren names */
 108
 109         /* Refcount of this regexp */
 110         I32 refcnt;             /* Refcount of this regexp */
 111 } regexp;
 112
 113 /* used for high speed searches */
 114 typedef struct re_scream_pos_data_s
 115 {
 116     char **scream_olds;         /* match pos */
 117     I32 *scream_pos;            /* Internal iterator of scream. */
 118 } re_scream_pos_data;
 119
 120 /* regexp_engine structure. This is the dispatch table for regexes.
 121  * Any regex engine implementation must be able to build one of these.
 122  */
 123 typedef struct regexp_engine {
 124     REGEXP* (*comp) (pTHX_ const SV * const pattern, const U32 flags);
 125     I32     (*exec) (pTHX_ REGEXP * const rx, char* stringarg, char* strend,
 126                      char* strbeg, I32 minend, SV* screamer,
 127                      void* data, U32 flags);
 128     char*   (*intuit) (pTHX_ REGEXP * const rx, SV *sv, char *strpos,
 129                        char *strend, const U32 flags,
 130                        re_scream_pos_data *data);
 131     SV*     (*checkstr) (pTHX_ REGEXP * const rx);
 132     void    (*free) (pTHX_ REGEXP * const rx);
 133     void    (*numbered_buff_FETCH) (pTHX_ REGEXP * const rx, const I32 paren,
 134                              SV * const sv);
 135     void    (*numbered_buff_STORE) (pTHX_ REGEXP * const rx, const I32 paren,
 136                                    SV const * const value);
 137     I32     (*numbered_buff_LENGTH) (pTHX_ REGEXP * const rx, const SV * const sv,
 138                                     const I32 paren);
 139     SV*     (*named_buff_FETCH) (pTHX_ REGEXP * const rx, SV * const key,
 140                                  const U32 flags);
 141     SV*     (*qr_package)(pTHX_ REGEXP * const rx);
 142 #ifdef USE_ITHREADS
 143     void*   (*dupe) (pTHX_ REGEXP * const rx, CLONE_PARAMS *param);
 144 #endif
 145 } regexp_engine;
 146
 147 /* Flags stored in regexp->extflags
 148  * These are used by code external to the regexp engine
 149  *
 150  * Note that flags starting with RXf_PMf_ have exact equivalents
 151  * stored in op_pmflags and which are defined in op.h, they are defined
 152  * numerically here only for clarity.
 153  */
 154
 155 /* Anchor and GPOS related stuff */
 156 #define RXf_ANCH_BOL            0x00000001
 157 #define RXf_ANCH_MBOL           0x00000002
 158 #define RXf_ANCH_SBOL           0x00000004
 159 #define RXf_ANCH_GPOS           0x00000008
 160 #define RXf_GPOS_SEEN           0x00000010
 161 #define RXf_GPOS_FLOAT          0x00000020
 162 /* two bits here */
 163 #define RXf_ANCH                (RXf_ANCH_BOL|RXf_ANCH_MBOL|RXf_ANCH_GPOS|RXf_ANCH_SBOL)
 164 #define RXf_GPOS_CHECK          (RXf_GPOS_SEEN|RXf_ANCH_GPOS)
 165 #define RXf_ANCH_SINGLE         (RXf_ANCH_SBOL|RXf_ANCH_GPOS)
 166
 167 /* Flags indicating special patterns */
 168 #define RXf_SKIPWHITE           0x00000100 /* Pattern is for a split / / */
 169 #define RXf_START_ONLY          0x00000200 /* Pattern is /^/ */
 170 #define RXf_WHITE               0x00000400 /* Pattern is /\s+/ */
 171
 172 /* 0x1F800 of extflags is used by (RXf_)PMf_COMPILETIME */
 173 #define RXf_PMf_LOCALE          0x00000800 /* use locale */
 174 #define RXf_PMf_MULTILINE       0x00001000 /* /m         */
 175 #define RXf_PMf_SINGLELINE      0x00002000 /* /s         */
 176 #define RXf_PMf_FOLD            0x00004000 /* /i         */
 177 #define RXf_PMf_EXTENDED        0x00008000 /* /x         */
 178 #define RXf_PMf_KEEPCOPY        0x00010000 /* /k         */
 179 /* these flags are transfered from the PMOP->op_pmflags member during compilation */
 180 #define RXf_PMf_STD_PMMOD       (RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_FOLD|RXf_PMf_EXTENDED)
 181 #define RXf_PMf_COMPILETIME     (RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_LOCALE|RXf_PMf_FOLD|RXf_PMf_EXTENDED|RXf_PMf_KEEPCOPY)
 182
 183 #define CASE_STD_PMMOD_FLAGS_PARSE_SET(pmfl)                        \
 184     case IGNORE_PAT_MOD:    *(pmfl) |= RXf_PMf_FOLD;       break;   \
 185     case MULTILINE_PAT_MOD: *(pmfl) |= RXf_PMf_MULTILINE;  break;   \
 186     case SINGLE_PAT_MOD:    *(pmfl) |= RXf_PMf_SINGLELINE; break;   \
 187     case XTENDED_PAT_MOD:   *(pmfl) |= RXf_PMf_EXTENDED;   break
 188
 189 /* chars and strings used as regex pattern modifiers
 190  * Singlular is a 'c'har, plural is a "string"
 191  *
 192  * NOTE, KEEPCOPY was originally 'k', but was changed to 'p' for preserve
 193  * for compatibility reasons with Regexp::Common which highjacked (?k:...)
 194  * for its own uses. So 'k' is out as well.
 195  */
 196 #define EXEC_PAT_MOD         'e'
 197 #define KEEPCOPY_PAT_MOD     'p'
 198 #define ONCE_PAT_MOD         'o'
 199 #define GLOBAL_PAT_MOD       'g'
 200 #define CONTINUE_PAT_MOD     'c'
 201 #define MULTILINE_PAT_MOD    'm'
 202 #define SINGLE_PAT_MOD       's'
 203 #define IGNORE_PAT_MOD       'i'
 204 #define XTENDED_PAT_MOD      'x'
 205
 206 #define ONCE_PAT_MODS        "o"
 207 #define KEEPCOPY_PAT_MODS    "p"
 208 #define EXEC_PAT_MODS        "e"
 209 #define LOOP_PAT_MODS        "gc"
 210
 211 #define STD_PAT_MODS        "msix"
 212
 213 #define INT_PAT_MODS    STD_PAT_MODS    KEEPCOPY_PAT_MODS
 214
 215 #define EXT_PAT_MODS    ONCE_PAT_MODS   KEEPCOPY_PAT_MODS
 216 #define QR_PAT_MODS     STD_PAT_MODS    EXT_PAT_MODS
 217 #define M_PAT_MODS      QR_PAT_MODS     LOOP_PAT_MODS
 218 #define S_PAT_MODS      M_PAT_MODS      EXEC_PAT_MODS
 219
 220
 221 /* What we have seen */
 222 #define RXf_LOOKBEHIND_SEEN     0x00020000
 223 #define RXf_EVAL_SEEN           0x00040000
 224 #define RXf_CANY_SEEN           0x00080000
 225
 226 /* Special */
 227 #define RXf_NOSCAN              0x00100000
 228 #define RXf_CHECK_ALL           0x00200000
 229
 230 /* UTF8 related */
 231 #define RXf_UTF8                0x00400000
 232 #define RXf_MATCH_UTF8          0x00800000
 233
 234 /* Intuit related */
 235 #define RXf_USE_INTUIT_NOML     0x01000000
 236 #define RXf_USE_INTUIT_ML       0x02000000
 237 #define RXf_INTUIT_TAIL         0x04000000
 238 /* one bit here */
 239 #define RXf_USE_INTUIT          (RXf_USE_INTUIT_NOML|RXf_USE_INTUIT_ML)
 240
 241 /* Copy and tainted info */
 242 #define RXf_COPY_DONE           0x10000000
 243 #define RXf_TAINTED_SEEN        0x20000000
 244 #define RXf_TAINTED             0x80000000 /* this pattern is tainted */
 245
 246
 247 #define RX_HAS_CUTGROUP(prog) ((prog)->intflags & PREGf_CUTGROUP_SEEN)
 248 #define RX_MATCH_TAINTED(prog)  ((prog)->extflags & RXf_TAINTED_SEEN)
 249 #define RX_MATCH_TAINTED_on(prog) ((prog)->extflags |= RXf_TAINTED_SEEN)
 250 #define RX_MATCH_TAINTED_off(prog) ((prog)->extflags &= ~RXf_TAINTED_SEEN)
 251 #define RX_MATCH_TAINTED_set(prog, t) ((t) \
 252                                        ? RX_MATCH_TAINTED_on(prog) \
 253                                        : RX_MATCH_TAINTED_off(prog))
 254
 255 #define RX_MATCH_COPIED(prog)           ((prog)->extflags & RXf_COPY_DONE)
 256 #define RX_MATCH_COPIED_on(prog)        ((prog)->extflags |= RXf_COPY_DONE)
 257 #define RX_MATCH_COPIED_off(prog)       ((prog)->extflags &= ~RXf_COPY_DONE)
 258 #define RX_MATCH_COPIED_set(prog,t)     ((t) \
 259                                          ? RX_MATCH_COPIED_on(prog) \
 260                                          : RX_MATCH_COPIED_off(prog))
 261
 262 #endif /* PLUGGABLE_RE_EXTENSION */
 263
 264 /* Stuff that needs to be included in the plugable extension goes below here */
 265
 266 #ifdef PERL_OLD_COPY_ON_WRITE
 267 #define RX_MATCH_COPY_FREE(rx) \
 268         STMT_START {if (rx->saved_copy) { \
 269             SV_CHECK_THINKFIRST_COW_DROP(rx->saved_copy); \
 270         } \
 271         if (RX_MATCH_COPIED(rx)) { \
 272             Safefree(rx->subbeg); \
 273             RX_MATCH_COPIED_off(rx); \
 274         }} STMT_END
 275 #else
 276 #define RX_MATCH_COPY_FREE(rx) \
 277         STMT_START {if (RX_MATCH_COPIED(rx)) { \
 278             Safefree(rx->subbeg); \
 279             RX_MATCH_COPIED_off(rx); \
 280         }} STMT_END
 281 #endif
 282
 283 #define RX_MATCH_UTF8(prog)             ((prog)->extflags & RXf_MATCH_UTF8)
 284 #define RX_MATCH_UTF8_on(prog)          ((prog)->extflags |= RXf_MATCH_UTF8)
 285 #define RX_MATCH_UTF8_off(prog)         ((prog)->extflags &= ~RXf_MATCH_UTF8)
 286 #define RX_MATCH_UTF8_set(prog, t)      ((t) \
 287                         ? (RX_MATCH_UTF8_on(prog), (PL_reg_match_utf8 = 1)) \
 288                         : (RX_MATCH_UTF8_off(prog), (PL_reg_match_utf8 = 0)))
 289
 290 #define REXEC_COPY_STR  0x01            /* Need to copy the string. */
 291 #define REXEC_CHECKED   0x02            /* check_substr already checked. */
 292 #define REXEC_SCREAM    0x04            /* use scream table. */
 293 #define REXEC_IGNOREPOS 0x08            /* \G matches at start. */
 294 #define REXEC_NOT_FIRST 0x10            /* This is another iteration of //g. */
 295
 296 #define ReREFCNT_inc(re) ((void)(re && re->refcnt++), re)
 297 #define ReREFCNT_dec(re) CALLREGFREE(re)
 298
 299 #define FBMcf_TAIL_DOLLAR       1
 300 #define FBMcf_TAIL_DOLLARM      2
 301 #define FBMcf_TAIL_Z            4
 302 #define FBMcf_TAIL_z            8
 303 #define FBMcf_TAIL              (FBMcf_TAIL_DOLLAR|FBMcf_TAIL_DOLLARM|FBMcf_TAIL_Z|FBMcf_TAIL_z)
 304
 305 #define FBMrf_MULTILINE 1
 306
 307 /* an accepting state/position*/
 308 struct _reg_trie_accepted {
 309     U8   *endpos;
 310     U16  wordnum;
 311 };
 312 typedef struct _reg_trie_accepted reg_trie_accepted;
 313
 314 /* some basic information about the current match that is created by
 315  * Perl_regexec_flags and then passed to regtry(), regmatch() etc */
 316
 317 typedef struct {
 318     regexp *prog;
 319     char *bol;
 320     char *till;
 321     SV *sv;
 322     char *ganch;
 323     char *cutpoint;
 324 } regmatch_info;
 325
 326
 327 /* structures for holding and saving the state maintained by regmatch() */
 328
 329 #ifndef MAX_RECURSE_EVAL_NOCHANGE_DEPTH
 330 #define MAX_RECURSE_EVAL_NOCHANGE_DEPTH 1000
 331 #endif
 332
 333 typedef I32 CHECKPOINT;
 334
 335 typedef struct regmatch_state {
 336     int resume_state;           /* where to jump to on return */
 337     char *locinput;             /* where to backtrack in string on failure */
 338
 339     union {
 340
 341         /* this is a fake union member that matches the first element
 342          * of each member that needs to store positive backtrack
 343          * information */
 344         struct {
 345             struct regmatch_state *prev_yes_state;
 346         } yes;
 347
 348         /* branchlike members */
 349         /* this is a fake union member that matches the first elements
 350          * of each member that needs to behave like a branch */
 351         struct {
 352             /* this first element must match u.yes */
 353             struct regmatch_state *prev_yes_state;
 354             U32 lastparen;
 355             CHECKPOINT cp;
 356
 357         } branchlike;
 358
 359         struct {
 360             /* the first elements must match u.branchlike */
 361             struct regmatch_state *prev_yes_state;
 362             U32 lastparen;
 363             CHECKPOINT cp;
 364
 365             regnode *next_branch; /* next branch node */
 366         } branch;
 367
 368         struct {
 369             /* the first elements must match u.branchlike */
 370             struct regmatch_state *prev_yes_state;
 371             U32 lastparen;
 372             CHECKPOINT cp;
 373
 374             reg_trie_accepted *accept_buff; /* accepting states we have seen */
 375             U32         accepted; /* how many accepting states we have seen */
 376             U16         *jump;  /* positive offsets from me */
 377             regnode     *B;     /* node following the trie */
 378             regnode     *me;    /* Which node am I - needed for jump tries*/
 379         } trie;
 380
 381         /* special types - these members are used to store state for special
 382            regops like eval, if/then, lookaround and the markpoint state */
 383         struct {
 384             /* this first element must match u.yes */
 385             struct regmatch_state *prev_yes_state;
 386             struct regmatch_state *prev_eval;
 387             struct regmatch_state *prev_curlyx;
 388             regexp      *prev_rex;
 389             U32         toggle_reg_flags; /* what bits in PL_reg_flags to
 390                                             flip when transitioning between
 391                                             inner and outer rexen */
 392             CHECKPOINT  cp;     /* remember current savestack indexes */
 393             CHECKPOINT  lastcp;
 394             U32        close_paren; /* which close bracket is our end */
 395             regnode     *B;     /* the node following us  */
 396         } eval;
 397
 398         struct {
 399             /* this first element must match u.yes */
 400             struct regmatch_state *prev_yes_state;
 401             I32 wanted;
 402             I32 logical;        /* saved copy of 'logical' var */
 403             regnode  *me; /* the IFMATCH/SUSPEND/UNLESSM node  */
 404         } ifmatch; /* and SUSPEND/UNLESSM */
 405
 406         struct {
 407             /* this first element must match u.yes */
 408             struct regmatch_state *prev_yes_state;
 409             struct regmatch_state *prev_mark;
 410             SV* mark_name;
 411             char *mark_loc;
 412         } mark;
 413
 414         struct {
 415             int val;
 416         } keeper;
 417
 418         /* quantifiers - these members are used for storing state for
 419            for the regops used to implement quantifiers */
 420         struct {
 421             /* this first element must match u.yes */
 422             struct regmatch_state *prev_yes_state;
 423             struct regmatch_state *prev_curlyx; /* previous cur_curlyx */
 424             regnode     *A, *B; /* the nodes corresponding to /A*B/  */
 425             CHECKPOINT  cp;     /* remember current savestack index */
 426             bool        minmod;
 427             int         parenfloor;/* how far back to strip paren data */
 428             int         min;    /* the minimal number of A's to match */
 429             int         max;    /* the maximal number of A's to match */
 430
 431             /* these two are modified by WHILEM */
 432             int         count;  /* how many instances of A we've matched */
 433             char        *lastloc;/* where previous A matched (0-len detect) */
 434         } curlyx;
 435
 436         struct {
 437             /* this first element must match u.yes */
 438             struct regmatch_state *prev_yes_state;
 439             struct regmatch_state *save_curlyx;
 440             CHECKPOINT  cp;     /* remember current savestack indexes */
 441             CHECKPOINT  lastcp;
 442             char        *save_lastloc;  /* previous curlyx.lastloc */
 443             I32         cache_offset;
 444             I32         cache_mask;
 445         } whilem;
 446
 447         struct {
 448             /* this first element must match u.yes */
 449             struct regmatch_state *prev_yes_state;
 450             I32 c1, c2;         /* case fold search */
 451             CHECKPOINT cp;
 452             I32 alen;           /* length of first-matched A string */
 453             I32 count;
 454             bool minmod;
 455             regnode *A, *B;     /* the nodes corresponding to /A*B/  */
 456             regnode *me;        /* the curlym node */
 457         } curlym;
 458
 459         struct {
 460             U32 paren;
 461             CHECKPOINT cp;
 462             I32 c1, c2;         /* case fold search */
 463             char *maxpos;       /* highest possible point in string to match */
 464             char *oldloc;       /* the previous locinput */
 465             int count;
 466             int min, max;       /* {m,n} */
 467             regnode *A, *B;     /* the nodes corresponding to /A*B/  */
 468         } curly; /* and CURLYN/PLUS/STAR */
 469
 470     } u;
 471 } regmatch_state;
 472
 473 /* how many regmatch_state structs to allocate as a single slab.
 474  * We do it in 4K blocks for efficiency. The "3" is 2 for the next/prev
 475  * pointers, plus 1 for any mythical malloc overhead. */
 476
 477 #define PERL_REGMATCH_SLAB_SLOTS \
 478     ((4096 - 3 * sizeof (void*)) / sizeof(regmatch_state))
 479
 480 typedef struct regmatch_slab {
 481     regmatch_state states[PERL_REGMATCH_SLAB_SLOTS];
 482     struct regmatch_slab *prev, *next;
 483 } regmatch_slab;
 484
 485 #define PL_reg_flags            PL_reg_state.re_state_reg_flags
 486 #define PL_bostr                PL_reg_state.re_state_bostr
 487 #define PL_reginput             PL_reg_state.re_state_reginput
 488 #define PL_regeol               PL_reg_state.re_state_regeol
 489 #define PL_regoffs              PL_reg_state.re_state_regoffs
 490 #define PL_reglastparen         PL_reg_state.re_state_reglastparen
 491 #define PL_reglastcloseparen    PL_reg_state.re_state_reglastcloseparen
 492 #define PL_reg_start_tmp        PL_reg_state.re_state_reg_start_tmp
 493 #define PL_reg_start_tmpl       PL_reg_state.re_state_reg_start_tmpl
 494 #define PL_reg_eval_set         PL_reg_state.re_state_reg_eval_set
 495 #define PL_reg_match_utf8       PL_reg_state.re_state_reg_match_utf8
 496 #define PL_reg_magic            PL_reg_state.re_state_reg_magic
 497 #define PL_reg_oldpos           PL_reg_state.re_state_reg_oldpos
 498 #define PL_reg_oldcurpm         PL_reg_state.re_state_reg_oldcurpm
 499 #define PL_reg_curpm            PL_reg_state.re_state_reg_curpm
 500 #define PL_reg_oldsaved         PL_reg_state.re_state_reg_oldsaved
 501 #define PL_reg_oldsavedlen      PL_reg_state.re_state_reg_oldsavedlen
 502 #define PL_reg_maxiter          PL_reg_state.re_state_reg_maxiter
 503 #define PL_reg_leftiter         PL_reg_state.re_state_reg_leftiter
 504 #define PL_reg_poscache         PL_reg_state.re_state_reg_poscache
 505 #define PL_reg_poscache_size    PL_reg_state.re_state_reg_poscache_size
 506 #define PL_regsize              PL_reg_state.re_state_regsize
 507 #define PL_reg_starttry         PL_reg_state.re_state_reg_starttry
 508 #define PL_nrs                  PL_reg_state.re_state_nrs
 509
 510 struct re_save_state {
 511     U32 re_state_reg_flags;             /* from regexec.c */
 512     U32 re_state_reg_start_tmpl;        /* from regexec.c */
 513     I32 re_state_reg_eval_set;          /* from regexec.c */
 514     bool re_state_reg_match_utf8;       /* from regexec.c */
 515     char *re_state_bostr;
 516     char *re_state_reginput;            /* String-input pointer. */
 517     char *re_state_regeol;              /* End of input, for $ check. */
 518     regexp_paren_pair *re_state_regoffs;  /* Pointer to start/end pairs */
 519     U32 *re_state_reglastparen;         /* Similarly for lastparen. */
 520     U32 *re_state_reglastcloseparen;    /* Similarly for lastcloseparen. */
 521     char **re_state_reg_start_tmp;      /* from regexec.c */
 522     MAGIC *re_state_reg_magic;          /* from regexec.c */
 523     PMOP *re_state_reg_oldcurpm;        /* from regexec.c */
 524     PMOP *re_state_reg_curpm;           /* from regexec.c */
 525     char *re_state_reg_oldsaved;        /* old saved substr during match */
 526     STRLEN re_state_reg_oldsavedlen;    /* old length of saved substr during match */
 527     STRLEN re_state_reg_poscache_size;  /* size of pos cache of WHILEM */
 528     I32 re_state_reg_oldpos;            /* from regexec.c */
 529     I32 re_state_reg_maxiter;           /* max wait until caching pos */
 530     I32 re_state_reg_leftiter;          /* wait until caching pos */
 531     U32 re_state_regsize;               /* from regexec.c */
 532     char *re_state_reg_poscache;        /* cache of pos of WHILEM */
 533     char *re_state_reg_starttry;        /* from regexec.c */
 534 #ifdef PERL_OLD_COPY_ON_WRITE
 535     SV *re_state_nrs;                   /* was placeholder: unused since 5.8.0 (5.7.2 patch #12027 for bug ID 20010815.012). Used to save rx->saved_copy */
 536 #endif
 537 };
 538
 539 #define SAVESTACK_ALLOC_FOR_RE_SAVE_STATE \
 540         (1 + ((sizeof(struct re_save_state) - 1) / sizeof(*PL_savestack)))
 541
 542 /*
 543  * Local variables:
 544  * c-indentation-style: bsd
 545  * c-basic-offset: 4
 546  * indent-tabs-mode: t
 547  * End:
 548  *
 549  * ex: set ts=8 sts=4 sw=4 noet:
 550  */