Simplify tests for fork() capabilities

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

diff --git a/regexp.h b/regexp.h
index 2f2997a..a9c2130 100644 (file)
--- a/regexp.h
+++ b/regexp.h
@@ -146,3 +146,144 @@ typedef struct regexp {
 #define FBMrf_MULTILINE        1
 
 struct re_scream_pos_data_s;
+
+/* an accepting state/position*/
+struct _reg_trie_accepted {
+    U8   *endpos;
+    U16  wordnum;
+};
+typedef struct _reg_trie_accepted reg_trie_accepted;
+
+
+/* structures for holding and saving the state maintained by regmatch() */
+
+typedef I32 CHECKPOINT;
+
+typedef struct re_cc_state
+{
+    I32 ss;
+    regnode *node;
+    struct re_cc_state *prev;
+    struct regmatch_state *cc; /* state corresponding to the current curly */
+    regexp *re;
+} re_cc_state;
+
+
+typedef enum {
+    resume_TRIE1,
+    resume_TRIE2,
+    resume_CURLYX,
+    resume_WHILEM1,
+    resume_WHILEM2,
+    resume_WHILEM3,
+    resume_WHILEM4,
+    resume_WHILEM5,
+    resume_WHILEM6,
+    resume_CURLYM1,
+    resume_CURLYM2,
+    resume_CURLYM3,
+    resume_CURLYM4,
+    resume_IFMATCH,
+    resume_PLUS1,
+    resume_PLUS2,
+    resume_PLUS3,
+    resume_PLUS4,
+    resume_END
+} regmatch_resume_states;
+
+
+typedef struct regmatch_state {
+
+    /* these vars contain state that needs to be maintained
+     * across the main while loop ... */
+
+    regmatch_resume_states resume_state; /* where to jump to on return */
+    regnode *scan;             /* Current node. */
+    regnode *next;             /* Next node. */
+    bool minmod;               /* the next "{n.m}" is a "{n,m}?" */
+    bool sw;                   /* the condition value in (?(cond)a|b) */
+    int logical;
+    I32 unwind;                        /* savestack index of current unwind block */
+    struct regmatch_state  *cc;        /* current innermost curly state */
+    char *locinput;
+
+    /* ... while the rest of these are local to an individual branch */
+
+    I32 n;                     /* no or next */
+    I32 ln;                    /* len or last */
+
+    union {
+       struct {
+           reg_trie_accepted *accept_buff;
+           U32 accepted;       /* how many accepting states we have seen */
+       } trie;
+
+       struct {
+           CHECKPOINT cp;      /* remember current savestack indexes */
+           CHECKPOINT lastcp;
+       } eval;
+
+       struct {
+           CHECKPOINT cp;      /* remember current savestack indexes */
+           struct regmatch_state *outercc; /* outer CURLYX state if any */
+
+           /* these contain the current curly state, and are accessed
+            * by subsequent WHILEMs */
+           int         parenfloor;/* how far back to strip paren data */
+           int         cur;    /* how many instances of scan we've matched */
+           int         min;    /* the minimal number of scans to match */
+           int         max;    /* the maximal number of scans to match */
+           regnode *   scan;   /* the thing to match */
+           char *      lastloc;/* where we started matching this scan */
+       } curlyx;
+
+       struct {
+           CHECKPOINT cp;      /* remember current savestack indexes */
+           CHECKPOINT lastcp;
+           struct regmatch_state *savecc;
+           char *lastloc;      /* Detection of 0-len. */
+           I32 cache_offset;
+           I32 cache_bit;
+       } whilem;
+
+       struct {
+           I32 paren;
+           I32 c1, c2;         /* case fold search */
+           CHECKPOINT lastcp;
+           I32 l;
+           I32 matches;
+           I32 maxwanted;
+       } curlym;
+
+       struct {
+           I32 paren;
+           CHECKPOINT lastcp;
+           I32 c1, c2;         /* case fold search */
+           char *e;
+           char *old;
+           int count;
+       } plus; /* and CURLYN/CURLY/STAR */
+
+       struct {
+           CHECKPOINT cp;      /* remember current savestack indexes */
+           CHECKPOINT lastcp;
+           struct regmatch_state *savecc;
+           re_cc_state *cur_call_cc;
+           regexp *end_re;
+       } end;
+    } u;
+
+    re_cc_state *reg_call_cc;  /* saved value of PL_reg_call_cc */
+} regmatch_state;
+
+/* how many regmatch_state structs to allocate as a single slab.
+ * We do it in 4K blocks for efficiency. The "3" is 2 for the next/prev
+ * pointers, plus 1 for any mythical malloc overhead. */
+ 
+#define PERL_REGMATCH_SLAB_SLOTS \
+    ((4096 - 3 * sizeof (void*)) / sizeof(regmatch_state))
+
+typedef struct regmatch_slab {
+    regmatch_state states[PERL_REGMATCH_SLAB_SLOTS];
+    struct regmatch_slab *prev, *next;
+} regmatch_slab;