regexec.c File Reference

#include "regex/regguts.h"
#include "rege_dfa.c"

Include dependency graph for regexec.c:

Go to the source code of this file.

Data Structures
struct	arcp
struct	sset
struct	dfa
struct	smalldfa
struct	vars

Macros
#define	HASH(bv, nw)   (((nw) == 1) ? *(bv) : hash(bv, nw))
#define	HIT(h, bv, ss, nw)
#define	STARTER   01 /* the initial state set */
#define	POSTSTATE   02 /* includes the goal state */
#define	LOCKED   04 /* locked in cache */
#define	NOPROGRESS   010 /* zero-progress state set */
#define	WORK   1 /* number of work bitvectors needed */
#define	FEWSTATES   20 /* must be less than UBITS */
#define	FEWCOLORS   15
#define	DOMALLOC   ((struct smalldfa *)NULL) /* force malloc */
#define	VISERR(vv)   ((vv)->err != 0) /* have we seen an error yet? */
#define	ISERR()   VISERR(v)
#define	VERR(vv, e)   ((vv)->err = ((vv)->err ? (vv)->err : (e)))
#define	ERR(e)   VERR(v, e) /* record an error */
#define	NOERR()   {if (ISERR()) return v->err;} /* if error seen, return it */
#define	OFF(p)   ((p) - v->start)
#define	LOFF(p)   ((long)OFF(p))
#define	LOCALMAT   20
#define	LOCALDFAS   40

Functions
static struct dfa *	getsubdfa (struct vars *v, struct subre *t)
static struct dfa *	getladfa (struct vars *v, int n)
static int	find (struct vars *v, struct cnfa *cnfa, struct colormap *cm)
static int	cfind (struct vars *v, struct cnfa *cnfa, struct colormap *cm)
static int	cfindloop (struct vars *v, struct cnfa *cnfa, struct colormap *cm, struct dfa *d, struct dfa *s, chr **coldp)
static void	zapallsubs (regmatch_t *p, size_t n)
static void	zaptreesubs (struct vars *v, struct subre *t)
static void	subset (struct vars *v, struct subre *sub, chr *begin, chr *end)
static int	cdissect (struct vars *v, struct subre *t, chr *begin, chr *end)
static int	ccondissect (struct vars *v, struct subre *t, chr *begin, chr *end)
static int	crevcondissect (struct vars *v, struct subre *t, chr *begin, chr *end)
static int	cbrdissect (struct vars *v, struct subre *t, chr *begin, chr *end)
static int	caltdissect (struct vars *v, struct subre *t, chr *begin, chr *end)
static int	citerdissect (struct vars *v, struct subre *t, chr *begin, chr *end)
static int	creviterdissect (struct vars *v, struct subre *t, chr *begin, chr *end)
static chr *	longest (struct vars *v, struct dfa *d, chr *start, chr *stop, int *hitstopp)
static chr *	shortest (struct vars *v, struct dfa *d, chr *start, chr *min, chr *max, chr **coldp, int *hitstopp)
static int	matchuntil (struct vars *v, struct dfa *d, chr *probe, struct sset **lastcss, chr **lastcp)
static chr *	dfa_backref (struct vars *v, struct dfa *d, chr *start, chr *min, chr *max, bool shortest)
static chr *	lastcold (struct vars *v, struct dfa *d)
static struct dfa *	newdfa (struct vars *v, struct cnfa *cnfa, struct colormap *cm, struct smalldfa *sml)
static void	freedfa (struct dfa *d)
static unsigned	hash (unsigned *uv, int n)
static struct sset *	initialize (struct vars *v, struct dfa *d, chr *start)
static struct sset *	miss (struct vars *v, struct dfa *d, struct sset *css, color co, chr *cp, chr *start)
static int	lacon (struct vars *v, struct cnfa *pcnfa, chr *cp, color co)
static struct sset *	getvacant (struct vars *v, struct dfa *d, chr *cp, chr *start)
static struct sset *	pickss (struct vars *v, struct dfa *d, chr *cp, chr *start)
int	pg_regexec (regex_t *re, const chr *string, size_t len, size_t search_start, rm_detail_t *details, size_t nmatch, regmatch_t pmatch[], int flags)

Macro Definition Documentation

DOMALLOC

#define DOMALLOC   ((struct smalldfa *)NULL) /* force malloc */

Definition at line 101 of file regexec.c.

ERR

#define ERR

(

e

)

VERR(v, e) /* record an error */

Definition at line 129 of file regexec.c.

FEWCOLORS

#define FEWCOLORS   15

Definition at line 91 of file regexec.c.

FEWSTATES

#define FEWSTATES   20 /* must be less than UBITS */

Definition at line 90 of file regexec.c.

HASH

#define HASH	(		bv,
			nw
	)		(((nw) == 1) ? *(bv) : hash(bv, nw))

Definition at line 49 of file regexec.c.

HIT

#define HIT	(		h,
			bv,
			ss,
			nw
	)

Value:

        ((ss)->hash == (h) && ((nw) == 1 || \
        memcmp(VS(bv), VS((ss)->states), (nw)*sizeof(unsigned)) == 0))

Definition at line 50 of file regexec.c.

ISERR

#define ISERR

(

)

VISERR(v)

Definition at line 127 of file regexec.c.

LOCALDFAS

#define LOCALDFAS   40

LOCALMAT

#define LOCALMAT   20

LOCKED

#define LOCKED   04 /* locked in cache */

Definition at line 55 of file regexec.c.

LOFF

#define LOFF

(

p

)

((long)OFF(p))

Definition at line 132 of file regexec.c.

NOERR

#define NOERR

(

)

{if (ISERR()) return v->err;} /* if error seen, return it */

Definition at line 130 of file regexec.c.

NOPROGRESS

#define NOPROGRESS   010 /* zero-progress state set */

Definition at line 56 of file regexec.c.

OFF

#define OFF

(

p

)

((p) - v->start)

Definition at line 131 of file regexec.c.

POSTSTATE

#define POSTSTATE   02 /* includes the goal state */

Definition at line 54 of file regexec.c.

STARTER

#define STARTER   01 /* the initial state set */

Definition at line 53 of file regexec.c.

VERR

#define VERR	(		vv,
			e
	)		((vv)->err = ((vv)->err ? (vv)->err : (e)))

Definition at line 128 of file regexec.c.

VISERR

#define VISERR

(

vv

)

((vv)->err != 0) /* have we seen an error yet? */

Definition at line 126 of file regexec.c.

WORK

#define WORK   1 /* number of work bitvectors needed */

Definition at line 87 of file regexec.c.

Function Documentation

caltdissect()

static int caltdissect ( struct vars *  v, struct subre *  t, chr *  begin, chr *  end  )

static

Definition at line 1076 of file regexec.c.

{
    struct dfa *d;
    int         er;
 
    assert(t->op == '|');
 
    t = t->child;
    /* there should be at least 2 alternatives */
    assert(t != NULL && t->sibling != NULL);
 
    while (t != NULL)
    {
        assert(t->cnfa.nstates > 0);
 
        MDEBUG(("%d: caltdissect %ld-%ld\n", t->id, LOFF(begin), LOFF(end)));
 
        d = getsubdfa(v, t);
        NOERR();
        if (longest(v, d, begin, end, (int *) NULL) == end)
        {
            MDEBUG(("%d: caltdissect matched\n", t->id));
            er = cdissect(v, t, begin, end);
            if (er != REG_NOMATCH)
                return er;
        }
        NOERR();
 
        t = t->sibling;
    }
 
    return REG_NOMATCH;
}

References assert, cdissect(), subre::child, subre::cnfa, getsubdfa(), subre::id, LOFF, longest(), MDEBUG, NOERR, cnfa::nstates, subre::op, REG_NOMATCH, and subre::sibling.

Referenced by cdissect().

cbrdissect()

static int cbrdissect ( struct vars *  v, struct subre *  t, chr *  begin, chr *  end  )

static

Definition at line 994 of file regexec.c.

{
    int         n = t->backno;
    size_t      numreps;
    size_t      tlen;
    size_t      brlen;
    chr        *brstring;
    chr        *p;
    int         min = t->min;
    int         max = t->max;
 
    assert(t != NULL);
    assert(t->op == 'b');
    assert(n >= 0);
    assert((size_t) n < v->nmatch);
 
    MDEBUG(("%d: cbrdissect %d{%d-%d} %ld-%ld\n", t->id, n, min, max,
            LOFF(begin), LOFF(end)));
 
    /* get the backreferenced string */
    if (v->pmatch[n].rm_so == -1)
        return REG_NOMATCH;
    brstring = v->start + v->pmatch[n].rm_so;
    brlen = v->pmatch[n].rm_eo - v->pmatch[n].rm_so;
 
    /* special cases for zero-length strings */
    if (brlen == 0)
    {
        /*
         * matches only if target is zero length, but any number of
         * repetitions can be considered to be present
         */
        if (begin == end && min <= max)
        {
            MDEBUG(("%d: backref matched trivially\n", t->id));
            return REG_OKAY;
        }
        return REG_NOMATCH;
    }
    if (begin == end)
    {
        /* matches only if zero repetitions are okay */
        if (min == 0)
        {
            MDEBUG(("%d: backref matched trivially\n", t->id));
            return REG_OKAY;
        }
        return REG_NOMATCH;
    }
 
    /*
     * check target length to see if it could possibly be an allowed number of
     * repetitions of brstring
     */
    assert(end > begin);
    tlen = end - begin;
    if (tlen % brlen != 0)
        return REG_NOMATCH;
    numreps = tlen / brlen;
    if (numreps < min || (numreps > max && max != DUPINF))
        return REG_NOMATCH;
 
    /* okay, compare the actual string contents */
    p = begin;
    while (numreps-- > 0)
    {
        if ((*v->g->compare) (brstring, p, brlen) != 0)
            return REG_NOMATCH;
        p += brlen;
    }
 
    MDEBUG(("%d: backref matched\n", t->id));
    return REG_OKAY;
}

References assert, subre::backno, DUPINF, vars::g, subre::id, LOFF, subre::max, MDEBUG, subre::min, subre::op, vars::pmatch, REG_NOMATCH, REG_OKAY, regmatch_t::rm_eo, regmatch_t::rm_so, and vars::start.

Referenced by cdissect().

ccondissect()

static int ccondissect ( struct vars *  v, struct subre *  t, chr *  begin, chr *  end  )

static

Definition at line 829 of file regexec.c.

{
    struct subre *left = t->child;
    struct subre *right = left->sibling;
    struct dfa *d;
    struct dfa *d2;
    chr        *mid;
    int         er;
 
    assert(t->op == '.');
    assert(left != NULL && left->cnfa.nstates > 0);
    assert(right != NULL && right->cnfa.nstates > 0);
    assert(right->sibling == NULL);
    assert(!(left->flags & SHORTER));
 
    d = getsubdfa(v, left);
    NOERR();
    d2 = getsubdfa(v, right);
    NOERR();
    MDEBUG(("%d: ccondissect %ld-%ld\n", t->id, LOFF(begin), LOFF(end)));
 
    /* pick a tentative midpoint */
    mid = longest(v, d, begin, end, (int *) NULL);
    NOERR();
    if (mid == NULL)
        return REG_NOMATCH;
    MDEBUG(("%d: tentative midpoint %ld\n", t->id, LOFF(mid)));
 
    /* iterate until satisfaction or failure */
    for (;;)
    {
        /* try this midpoint on for size */
        if (longest(v, d2, mid, end, (int *) NULL) == end)
        {
            er = cdissect(v, left, begin, mid);
            if (er == REG_OKAY)
            {
                er = cdissect(v, right, mid, end);
                if (er == REG_OKAY)
                {
                    /* satisfaction */
                    MDEBUG(("%d: successful\n", t->id));
                    return REG_OKAY;
                }
                /* Reset left's matches (right should have done so itself) */
                zaptreesubs(v, left);
            }
            if (er != REG_NOMATCH)
                return er;
        }
        NOERR();
 
        /* that midpoint didn't work, find a new one */
        if (mid == begin)
        {
            /* all possibilities exhausted */
            MDEBUG(("%d: no midpoint\n", t->id));
            return REG_NOMATCH;
        }
        mid = longest(v, d, begin, mid - 1, (int *) NULL);
        NOERR();
        if (mid == NULL)
        {
            /* failed to find a new one */
            MDEBUG(("%d: failed midpoint\n", t->id));
            return REG_NOMATCH;
        }
        MDEBUG(("%d: new midpoint %ld\n", t->id, LOFF(mid)));
    }
 
    /* can't get here */
    return REG_ASSERT;
}

References assert, cdissect(), subre::child, subre::cnfa, subre::flags, getsubdfa(), subre::id, LOFF, longest(), MDEBUG, NOERR, cnfa::nstates, subre::op, REG_ASSERT, REG_NOMATCH, REG_OKAY, SHORTER, subre::sibling, and zaptreesubs().

Referenced by cdissect().

cdissect()

static int cdissect ( struct vars *  v, struct subre *  t, chr *  begin, chr *  end  )

static

Definition at line 756 of file regexec.c.

{
    int         er;
 
    assert(t != NULL);
    MDEBUG(("%d: cdissect %c %ld-%ld\n", t->id, t->op, LOFF(begin), LOFF(end)));
 
    /* handy place to check for operation cancel */
    INTERRUPT(v->re);
    /* ... and stack overrun */
    if (STACK_TOO_DEEP(v->re))
        return REG_ETOOBIG;
 
    switch (t->op)
    {
        case '=':               /* terminal node */
            assert(t->child == NULL);
            er = REG_OKAY;      /* no action, parent did the work */
            break;
        case 'b':               /* back reference */
            assert(t->child == NULL);
            er = cbrdissect(v, t, begin, end);
            break;
        case '.':               /* concatenation */
            assert(t->child != NULL);
            if (t->child->flags & SHORTER)  /* reverse scan */
                er = crevcondissect(v, t, begin, end);
            else
                er = ccondissect(v, t, begin, end);
            break;
        case '|':               /* alternation */
            assert(t->child != NULL);
            er = caltdissect(v, t, begin, end);
            break;
        case '*':               /* iteration */
            assert(t->child != NULL);
            if (t->child->flags & SHORTER)  /* reverse scan */
                er = creviterdissect(v, t, begin, end);
            else
                er = citerdissect(v, t, begin, end);
            break;
        case '(':               /* no-op capture node */
            assert(t->child != NULL);
            er = cdissect(v, t->child, begin, end);
            break;
        default:
            er = REG_ASSERT;
            break;
    }
 
    /*
     * We should never have a match failure unless backrefs lurk below;
     * otherwise, either caller failed to check the DFA, or there's some
     * inconsistency between the DFA and the node's innards.
     */
    assert(er != REG_NOMATCH || (t->flags & BACKR));
 
    /*
     * If this node is marked as capturing, save successful match's location.
     */
    if (t->capno > 0 && er == REG_OKAY)
        subset(v, t, begin, end);
 
    return er;
}

References assert, BACKR, subre::begin, caltdissect(), subre::capno, cbrdissect(), ccondissect(), subre::child, citerdissect(), crevcondissect(), creviterdissect(), subre::end, subre::flags, subre::id, INTERRUPT, LOFF, MDEBUG, subre::op, vars::re, REG_ASSERT, REG_ETOOBIG, REG_NOMATCH, REG_OKAY, SHORTER, STACK_TOO_DEEP, and subset().

Referenced by caltdissect(), ccondissect(), cfindloop(), citerdissect(), crevcondissect(), creviterdissect(), and find().

cfind()

static int cfind ( struct vars *  v, struct cnfa *  cnfa, struct colormap *  cm  )

static

Definition at line 509 of file regexec.c.

{
    struct dfa *s;
    struct dfa *d;
    chr        *cold;
    int         ret;
 
    s = newdfa(v, &v->g->search, cm, &v->dfa1);
    if (s == NULL)
        return v->err;
    d = newdfa(v, cnfa, cm, &v->dfa2);
    if (d == NULL)
    {
        freedfa(s);
        return v->err;
    }
 
    ret = cfindloop(v, cnfa, cm, d, s, &cold);
 
    freedfa(d);
    freedfa(s);
    NOERR();
    if (v->g->cflags & REG_EXPECT)
    {
        assert(v->details != NULL);
        if (cold != NULL)
            v->details->rm_extend.rm_so = OFF(cold);
        else
            v->details->rm_extend.rm_so = OFF(v->stop);
        v->details->rm_extend.rm_eo = OFF(v->stop); /* unknown */
    }
    return ret;
}

References assert, cfindloop(), guts::cflags, dfa::cm, vars::details, vars::dfa1, vars::dfa2, vars::err, freedfa(), vars::g, newdfa(), NOERR, OFF, REG_EXPECT, regmatch_t::rm_eo, rm_detail_t::rm_extend, regmatch_t::rm_so, guts::search, and vars::stop.

Referenced by pg_regexec().

cfindloop()

static int cfindloop ( struct vars *  v, struct cnfa *  cnfa, struct colormap *  cm, struct dfa *  d, struct dfa *  s, chr **  coldp  )

static

Definition at line 549 of file regexec.c.

{
    chr        *begin;
    chr        *end;
    chr        *cold;
    chr        *open;           /* open and close of range of possible starts */
    chr        *close;
    chr        *estart;
    chr        *estop;
    int         er;
    int         shorter = v->g->tree->flags & SHORTER;
    int         hitend;
 
    assert(d != NULL && s != NULL);
    cold = NULL;
    close = v->search_start;
    do
    {
        /* Search with the search RE for match range at/beyond "close" */
        MDEBUG(("\ncsearch at %ld\n", LOFF(close)));
        close = shortest(v, s, close, close, v->stop, &cold, (int *) NULL);
        if (ISERR())
        {
            *coldp = cold;
            return v->err;
        }
        if (close == NULL)
            break;              /* no more possible match anywhere */
        assert(cold != NULL);
        open = cold;
        cold = NULL;
        /* Search for matches starting between "open" and "close" inclusive */
        MDEBUG(("cbetween %ld and %ld\n", LOFF(open), LOFF(close)));
        for (begin = open; begin <= close; begin++)
        {
            MDEBUG(("\ncfind trying at %ld\n", LOFF(begin)));
            estart = begin;
            estop = v->stop;
            for (;;)
            {
                /* Here we use the top node's detailed RE */
                if (shorter)
                    end = shortest(v, d, begin, estart,
                                   estop, (chr **) NULL, &hitend);
                else
                    end = longest(v, d, begin, estop,
                                  &hitend);
                if (ISERR())
                {
                    *coldp = cold;
                    return v->err;
                }
                if (hitend && cold == NULL)
                    cold = begin;
                if (end == NULL)
                    break;      /* no match with this begin point, try next */
                MDEBUG(("tentative end %ld\n", LOFF(end)));
                /* Dissect the potential match to see if it really matches */
                er = cdissect(v, v->g->tree, begin, end);
                if (er == REG_OKAY)
                {
                    if (v->nmatch > 0)
                    {
                        v->pmatch[0].rm_so = OFF(begin);
                        v->pmatch[0].rm_eo = OFF(end);
                    }
                    *coldp = cold;
                    return REG_OKAY;
                }
                if (er != REG_NOMATCH)
                {
                    ERR(er);
                    *coldp = cold;
                    return er;
                }
                /* Try next longer/shorter match with same begin point */
                if (shorter)
                {
                    if (end == estop)
                        break;  /* no more, so try next begin point */
                    estart = end + 1;
                }
                else
                {
                    if (end == begin)
                        break;  /* no more, so try next begin point */
                    estop = end - 1;
                }
            }                   /* end loop over endpoint positions */
        }                       /* end loop over beginning positions */
 
        /*
         * If we get here, there is no possible match starting at or before
         * "close", so consider matches beyond that.  We'll do a fresh search
         * with the search RE to find a new promising match range.
         */
        close++;
    } while (close < v->stop);
 
    *coldp = cold;
    return REG_NOMATCH;
}

References assert, cdissect(), close, vars::err, ERR, subre::flags, vars::g, ISERR, LOFF, longest(), MDEBUG, vars::nmatch, OFF, vars::pmatch, REG_NOMATCH, REG_OKAY, regmatch_t::rm_eo, regmatch_t::rm_so, vars::search_start, SHORTER, shortest(), vars::stop, and guts::tree.

Referenced by cfind().

citerdissect()

static int citerdissect ( struct vars *  v, struct subre *  t, chr *  begin, chr *  end  )

static

Definition at line 1117 of file regexec.c.

{
    struct dfa *d;
    chr       **endpts;
    chr        *limit;
    int         min_matches;
    size_t      max_matches;
    int         nverified;
    int         k;
    int         i;
    int         er;
 
    assert(t->op == '*');
    assert(t->child != NULL && t->child->cnfa.nstates > 0);
    assert(!(t->child->flags & SHORTER));
    assert(begin <= end);
 
    MDEBUG(("%d: citerdissect %ld-%ld\n", t->id, LOFF(begin), LOFF(end)));
 
    /*
     * For the moment, assume the minimum number of matches is 1.  If zero
     * matches are allowed, and the target string is empty, we are allowed to
     * match regardless of the contents of the iter node --- but we would
     * prefer to match once, so that capturing parens get set.  (An example of
     * the concern here is a pattern like "()*\1", which historically this
     * code has allowed to succeed.)  Therefore, we deal with the zero-matches
     * case at the bottom, after failing to find any other way to match.
     */
    min_matches = t->min;
    if (min_matches <= 0)
        min_matches = 1;
 
    /*
     * We need workspace to track the endpoints of each sub-match.  Normally
     * we consider only nonzero-length sub-matches, so there can be at most
     * end-begin of them.  However, if min is larger than that, we will also
     * consider zero-length sub-matches in order to find enough matches.
     *
     * For convenience, endpts[0] contains the "begin" pointer and we store
     * sub-match endpoints in endpts[1..max_matches].
     */
    max_matches = end - begin;
    if (max_matches > t->max && t->max != DUPINF)
        max_matches = t->max;
    if (max_matches < min_matches)
        max_matches = min_matches;
    endpts = (chr **) MALLOC((max_matches + 1) * sizeof(chr *));
    if (endpts == NULL)
        return REG_ESPACE;
    endpts[0] = begin;
 
    d = getsubdfa(v, t->child);
    if (ISERR())
    {
        FREE(endpts);
        return v->err;
    }
 
    /*
     * Our strategy is to first find a set of sub-match endpoints that are
     * valid according to the child node's DFA, and then recursively dissect
     * each sub-match to confirm validity.  If any validity check fails,
     * backtrack that sub-match and try again.  And, when we next try for a
     * validity check, we need not recheck any successfully verified
     * sub-matches that we didn't move the endpoints of.  nverified remembers
     * how many sub-matches are currently known okay.
     */
 
    /* initialize to consider first sub-match */
    nverified = 0;
    k = 1;
    limit = end;
 
    /* iterate until satisfaction or failure */
    while (k > 0)
    {
        /* try to find an endpoint for the k'th sub-match */
        endpts[k] = longest(v, d, endpts[k - 1], limit, (int *) NULL);
        if (ISERR())
        {
            FREE(endpts);
            return v->err;
        }
        if (endpts[k] == NULL)
        {
            /* no match possible, so see if we can shorten previous one */
            k--;
            goto backtrack;
        }
        MDEBUG(("%d: working endpoint %d: %ld\n",
                t->id, k, LOFF(endpts[k])));
 
        /* k'th sub-match can no longer be considered verified */
        if (nverified >= k)
            nverified = k - 1;
 
        if (endpts[k] != end)
        {
            /* haven't reached end yet, try another iteration if allowed */
            if (k >= max_matches)
            {
                /* must try to shorten some previous match */
                k--;
                goto backtrack;
            }
 
            /* reject zero-length match unless necessary to achieve min */
            if (endpts[k] == endpts[k - 1] &&
                (k >= min_matches || min_matches - k < end - endpts[k]))
                goto backtrack;
 
            k++;
            limit = end;
            continue;
        }
 
        /*
         * We've identified a way to divide the string into k sub-matches that
         * works so far as the child DFA can tell.  If k is an allowed number
         * of matches, start the slow part: recurse to verify each sub-match.
         * We always have k <= max_matches, needn't check that.
         */
        if (k < min_matches)
            goto backtrack;
 
        MDEBUG(("%d: verifying %d..%d\n", t->id, nverified + 1, k));
 
        for (i = nverified + 1; i <= k; i++)
        {
            /* zap any match data from a non-last iteration */
            zaptreesubs(v, t->child);
            er = cdissect(v, t->child, endpts[i - 1], endpts[i]);
            if (er == REG_OKAY)
            {
                nverified = i;
                continue;
            }
            if (er == REG_NOMATCH)
                break;
            /* oops, something failed */
            FREE(endpts);
            return er;
        }
 
        if (i > k)
        {
            /* satisfaction */
            MDEBUG(("%d: successful\n", t->id));
            FREE(endpts);
            return REG_OKAY;
        }
 
        /* i'th match failed to verify, so backtrack it */
        k = i;
 
backtrack:
 
        /*
         * Must consider shorter versions of the k'th sub-match.  However,
         * we'll only ask for a zero-length match if necessary.
         */
        while (k > 0)
        {
            chr        *prev_end = endpts[k - 1];
 
            if (endpts[k] > prev_end)
            {
                limit = endpts[k] - 1;
                if (limit > prev_end ||
                    (k < min_matches && min_matches - k >= end - prev_end))
                {
                    /* break out of backtrack loop, continue the outer one */
                    break;
                }
            }
            /* can't shorten k'th sub-match any more, consider previous one */
            k--;
        }
    }
 
    /* all possibilities exhausted */
    FREE(endpts);
 
    /*
     * Now consider the possibility that we can match to a zero-length string
     * by using zero repetitions.
     */
    if (t->min == 0 && begin == end)
    {
        MDEBUG(("%d: allowing zero matches\n", t->id));
        return REG_OKAY;
    }
 
    MDEBUG(("%d: failed\n", t->id));
    return REG_NOMATCH;
}

References assert, cdissect(), subre::child, subre::cnfa, DUPINF, vars::err, subre::flags, FREE, getsubdfa(), i, subre::id, ISERR, LOFF, longest(), MALLOC, subre::max, MDEBUG, subre::min, cnfa::nstates, subre::op, REG_ESPACE, REG_NOMATCH, REG_OKAY, SHORTER, and zaptreesubs().

Referenced by cdissect().

crevcondissect()

static int crevcondissect ( struct vars *  v, struct subre *  t, chr *  begin, chr *  end  )

static

Definition at line 910 of file regexec.c.

{
    struct subre *left = t->child;
    struct subre *right = left->sibling;
    struct dfa *d;
    struct dfa *d2;
    chr        *mid;
    int         er;
 
    assert(t->op == '.');
    assert(left != NULL && left->cnfa.nstates > 0);
    assert(right != NULL && right->cnfa.nstates > 0);
    assert(right->sibling == NULL);
    assert(left->flags & SHORTER);
 
    d = getsubdfa(v, left);
    NOERR();
    d2 = getsubdfa(v, right);
    NOERR();
    MDEBUG(("%d: crevcondissect %ld-%ld\n", t->id, LOFF(begin), LOFF(end)));
 
    /* pick a tentative midpoint */
    mid = shortest(v, d, begin, begin, end, (chr **) NULL, (int *) NULL);
    NOERR();
    if (mid == NULL)
        return REG_NOMATCH;
    MDEBUG(("%d: tentative midpoint %ld\n", t->id, LOFF(mid)));
 
    /* iterate until satisfaction or failure */
    for (;;)
    {
        /* try this midpoint on for size */
        if (longest(v, d2, mid, end, (int *) NULL) == end)
        {
            er = cdissect(v, left, begin, mid);
            if (er == REG_OKAY)
            {
                er = cdissect(v, right, mid, end);
                if (er == REG_OKAY)
                {
                    /* satisfaction */
                    MDEBUG(("%d: successful\n", t->id));
                    return REG_OKAY;
                }
                /* Reset left's matches (right should have done so itself) */
                zaptreesubs(v, left);
            }
            if (er != REG_NOMATCH)
                return er;
        }
        NOERR();
 
        /* that midpoint didn't work, find a new one */
        if (mid == end)
        {
            /* all possibilities exhausted */
            MDEBUG(("%d: no midpoint\n", t->id));
            return REG_NOMATCH;
        }
        mid = shortest(v, d, begin, mid + 1, end, (chr **) NULL, (int *) NULL);
        NOERR();
        if (mid == NULL)
        {
            /* failed to find a new one */
            MDEBUG(("%d: failed midpoint\n", t->id));
            return REG_NOMATCH;
        }
        MDEBUG(("%d: new midpoint %ld\n", t->id, LOFF(mid)));
    }
 
    /* can't get here */
    return REG_ASSERT;
}

References assert, cdissect(), subre::child, subre::cnfa, subre::flags, getsubdfa(), subre::id, LOFF, longest(), MDEBUG, NOERR, cnfa::nstates, subre::op, REG_ASSERT, REG_NOMATCH, REG_OKAY, SHORTER, shortest(), subre::sibling, and zaptreesubs().

Referenced by cdissect().

creviterdissect()

static int creviterdissect ( struct vars *  v, struct subre *  t, chr *  begin, chr *  end  )

static

Definition at line 1321 of file regexec.c.

{
    struct dfa *d;
    chr       **endpts;
    chr        *limit;
    int         min_matches;
    size_t      max_matches;
    int         nverified;
    int         k;
    int         i;
    int         er;
 
    assert(t->op == '*');
    assert(t->child != NULL && t->child->cnfa.nstates > 0);
    assert(t->child->flags & SHORTER);
    assert(begin <= end);
 
    MDEBUG(("%d: creviterdissect %ld-%ld\n", t->id, LOFF(begin), LOFF(end)));
 
    /*
     * If zero matches are allowed, and target string is empty, just declare
     * victory.  OTOH, if target string isn't empty, zero matches can't work
     * so we pretend the min is 1.
     */
    min_matches = t->min;
    if (min_matches <= 0)
    {
        if (begin == end)
        {
            MDEBUG(("%d: allowing zero matches\n", t->id));
            return REG_OKAY;
        }
        min_matches = 1;
    }
 
    /*
     * We need workspace to track the endpoints of each sub-match.  Normally
     * we consider only nonzero-length sub-matches, so there can be at most
     * end-begin of them.  However, if min is larger than that, we will also
     * consider zero-length sub-matches in order to find enough matches.
     *
     * For convenience, endpts[0] contains the "begin" pointer and we store
     * sub-match endpoints in endpts[1..max_matches].
     */
    max_matches = end - begin;
    if (max_matches > t->max && t->max != DUPINF)
        max_matches = t->max;
    if (max_matches < min_matches)
        max_matches = min_matches;
    endpts = (chr **) MALLOC((max_matches + 1) * sizeof(chr *));
    if (endpts == NULL)
        return REG_ESPACE;
    endpts[0] = begin;
 
    d = getsubdfa(v, t->child);
    if (ISERR())
    {
        FREE(endpts);
        return v->err;
    }
 
    /*
     * Our strategy is to first find a set of sub-match endpoints that are
     * valid according to the child node's DFA, and then recursively dissect
     * each sub-match to confirm validity.  If any validity check fails,
     * backtrack that sub-match and try again.  And, when we next try for a
     * validity check, we need not recheck any successfully verified
     * sub-matches that we didn't move the endpoints of.  nverified remembers
     * how many sub-matches are currently known okay.
     */
 
    /* initialize to consider first sub-match */
    nverified = 0;
    k = 1;
    limit = begin;
 
    /* iterate until satisfaction or failure */
    while (k > 0)
    {
        /* disallow zero-length match unless necessary to achieve min */
        if (limit == endpts[k - 1] &&
            limit != end &&
            (k >= min_matches || min_matches - k < end - limit))
            limit++;
 
        /* if this is the last allowed sub-match, it must reach to the end */
        if (k >= max_matches)
            limit = end;
 
        /* try to find an endpoint for the k'th sub-match */
        endpts[k] = shortest(v, d, endpts[k - 1], limit, end,
                             (chr **) NULL, (int *) NULL);
        if (ISERR())
        {
            FREE(endpts);
            return v->err;
        }
        if (endpts[k] == NULL)
        {
            /* no match possible, so see if we can lengthen previous one */
            k--;
            goto backtrack;
        }
        MDEBUG(("%d: working endpoint %d: %ld\n",
                t->id, k, LOFF(endpts[k])));
 
        /* k'th sub-match can no longer be considered verified */
        if (nverified >= k)
            nverified = k - 1;
 
        if (endpts[k] != end)
        {
            /* haven't reached end yet, try another iteration if allowed */
            if (k >= max_matches)
            {
                /* must try to lengthen some previous match */
                k--;
                goto backtrack;
            }
 
            k++;
            limit = endpts[k - 1];
            continue;
        }
 
        /*
         * We've identified a way to divide the string into k sub-matches that
         * works so far as the child DFA can tell.  If k is an allowed number
         * of matches, start the slow part: recurse to verify each sub-match.
         * We always have k <= max_matches, needn't check that.
         */
        if (k < min_matches)
            goto backtrack;
 
        MDEBUG(("%d: verifying %d..%d\n", t->id, nverified + 1, k));
 
        for (i = nverified + 1; i <= k; i++)
        {
            /* zap any match data from a non-last iteration */
            zaptreesubs(v, t->child);
            er = cdissect(v, t->child, endpts[i - 1], endpts[i]);
            if (er == REG_OKAY)
            {
                nverified = i;
                continue;
            }
            if (er == REG_NOMATCH)
                break;
            /* oops, something failed */
            FREE(endpts);
            return er;
        }
 
        if (i > k)
        {
            /* satisfaction */
            MDEBUG(("%d: successful\n", t->id));
            FREE(endpts);
            return REG_OKAY;
        }
 
        /* i'th match failed to verify, so backtrack it */
        k = i;
 
backtrack:
 
        /*
         * Must consider longer versions of the k'th sub-match.
         */
        while (k > 0)
        {
            if (endpts[k] < end)
            {
                limit = endpts[k] + 1;
                /* break out of backtrack loop, continue the outer one */
                break;
            }
            /* can't lengthen k'th sub-match any more, consider previous one */
            k--;
        }
    }
 
    /* all possibilities exhausted */
    MDEBUG(("%d: failed\n", t->id));
    FREE(endpts);
    return REG_NOMATCH;
}

References assert, cdissect(), subre::child, subre::cnfa, DUPINF, vars::err, subre::flags, FREE, getsubdfa(), i, subre::id, ISERR, LOFF, MALLOC, subre::max, MDEBUG, subre::min, cnfa::nstates, subre::op, REG_ESPACE, REG_NOMATCH, REG_OKAY, SHORTER, shortest(), and zaptreesubs().

Referenced by cdissect().

dfa_backref()

static chr* dfa_backref ( struct vars *  v, struct dfa *  d, chr *  start, chr *  min, chr *  max, bool  shortest  )

static

find()

static int find ( struct vars *  v, struct cnfa *  cnfa, struct colormap *  cm  )

static

Definition at line 419 of file regexec.c.

{
    struct dfa *s;
    struct dfa *d;
    chr        *begin;
    chr        *end = NULL;
    chr        *cold;
    chr        *open;           /* open and close of range of possible starts */
    chr        *close;
    int         hitend;
    int         shorter = (v->g->tree->flags & SHORTER) ? 1 : 0;
 
    /* first, a shot with the search RE */
    s = newdfa(v, &v->g->search, cm, &v->dfa1);
    if (s == NULL)
        return v->err;
    MDEBUG(("\nsearch at %ld\n", LOFF(v->start)));
    cold = NULL;
    close = shortest(v, s, v->search_start, v->search_start, v->stop,
                     &cold, (int *) NULL);
    freedfa(s);
    NOERR();
    if (v->g->cflags & REG_EXPECT)
    {
        assert(v->details != NULL);
        if (cold != NULL)
            v->details->rm_extend.rm_so = OFF(cold);
        else
            v->details->rm_extend.rm_so = OFF(v->stop);
        v->details->rm_extend.rm_eo = OFF(v->stop); /* unknown */
    }
    if (close == NULL)          /* not found */
        return REG_NOMATCH;
    if (v->nmatch == 0)         /* found, don't need exact location */
        return REG_OKAY;
 
    /* find starting point and match */
    assert(cold != NULL);
    open = cold;
    cold = NULL;
    MDEBUG(("between %ld and %ld\n", LOFF(open), LOFF(close)));
    d = newdfa(v, cnfa, cm, &v->dfa1);
    if (d == NULL)
        return v->err;
    for (begin = open; begin <= close; begin++)
    {
        MDEBUG(("\nfind trying at %ld\n", LOFF(begin)));
        if (shorter)
            end = shortest(v, d, begin, begin, v->stop,
                           (chr **) NULL, &hitend);
        else
            end = longest(v, d, begin, v->stop, &hitend);
        if (ISERR())
        {
            freedfa(d);
            return v->err;
        }
        if (hitend && cold == NULL)
            cold = begin;
        if (end != NULL)
            break;              /* NOTE BREAK OUT */
    }
    assert(end != NULL);        /* search RE succeeded so loop should */
    freedfa(d);
 
    /* and pin down details */
    assert(v->nmatch > 0);
    v->pmatch[0].rm_so = OFF(begin);
    v->pmatch[0].rm_eo = OFF(end);
    if (v->g->cflags & REG_EXPECT)
    {
        if (cold != NULL)
            v->details->rm_extend.rm_so = OFF(cold);
        else
            v->details->rm_extend.rm_so = OFF(v->stop);
        v->details->rm_extend.rm_eo = OFF(v->stop); /* unknown */
    }
    if (v->nmatch == 1)         /* no need for submatches */
        return REG_OKAY;
 
    /* find submatches */
    return cdissect(v, v->g->tree, begin, end);
}

References assert, cdissect(), guts::cflags, close, dfa::cm, vars::details, vars::dfa1, vars::err, subre::flags, freedfa(), vars::g, ISERR, LOFF, longest(), MDEBUG, newdfa(), vars::nmatch, NOERR, OFF, vars::pmatch, REG_EXPECT, REG_NOMATCH, REG_OKAY, regmatch_t::rm_eo, rm_detail_t::rm_extend, regmatch_t::rm_so, guts::search, vars::search_start, SHORTER, shortest(), vars::start, vars::stop, and guts::tree.

Referenced by NIAddAffix(), NIImportAffixes(), NIImportOOAffixes(), parse_affentry(), parse_ooaffentry(), pg_regexec(), and testdelete().

freedfa()

static void freedfa ( struct dfa *  d )

static

Referenced by cfind(), find(), and pg_regexec().

getladfa()

static struct dfa * getladfa ( struct vars *  v, int  n  )

static

Definition at line 400 of file regexec.c.

{
    assert(n > 0 && n < v->g->nlacons && v->g->lacons != NULL);
 
    if (v->ladfas[n] == NULL)
    {
        struct subre *sub = &v->g->lacons[n];
 
        v->ladfas[n] = newdfa(v, &sub->cnfa, &v->g->cmap, DOMALLOC);
        /* a LACON can't contain a backref, so nothing else to do */
    }
    return v->ladfas[n];
}

References assert, guts::cmap, subre::cnfa, DOMALLOC, vars::g, guts::lacons, vars::ladfas, and newdfa().

Referenced by lacon().

getsubdfa()

static struct dfa * getsubdfa ( struct vars *  v, struct subre *  t  )

static

Definition at line 372 of file regexec.c.

{
    struct dfa *d = v->subdfas[t->id];
 
    if (d == NULL)
    {
        d = newdfa(v, &t->cnfa, &v->g->cmap, DOMALLOC);
        if (d == NULL)
            return NULL;
        /* set up additional info if this is a backref node */
        if (t->op == 'b')
        {
            d->backno = t->backno;
            d->backmin = t->min;
            d->backmax = t->max;
        }
        v->subdfas[t->id] = d;
    }
    return d;
}

References dfa::backmax, dfa::backmin, dfa::backno, subre::backno, guts::cmap, subre::cnfa, DOMALLOC, vars::g, subre::id, subre::max, subre::min, newdfa(), subre::op, and vars::subdfas.

Referenced by caltdissect(), ccondissect(), citerdissect(), crevcondissect(), and creviterdissect().

getvacant()

static struct sset* getvacant ( struct vars *  v, struct dfa *  d, chr *  cp, chr *  start  )

static

hash()

static unsigned hash ( unsigned *  uv, int  n  )

static

initialize()

static struct sset* initialize ( struct vars *  v, struct dfa *  d, chr *  start  )

static

lacon()

static int lacon ( struct vars *  v, struct cnfa *  pcnfa, chr *  cp, color  co  )

static

lastcold()

static chr* lastcold ( struct vars *  v, struct dfa *  d  )

static

longest()

static chr* longest ( struct vars *  v, struct dfa *  d, chr *  start, chr *  stop, int *  hitstopp  )

static

Referenced by caltdissect(), ccondissect(), cfindloop(), citerdissect(), crevcondissect(), and find().

matchuntil()

static int matchuntil ( struct vars *  v, struct dfa *  d, chr *  probe, struct sset **  lastcss, chr **  lastcp  )

static

miss()

static struct sset* miss ( struct vars *  v, struct dfa *  d, struct sset *  css, color  co, chr *  cp, chr *  start  )

static

newdfa()

static struct dfa* newdfa ( struct vars *  v, struct cnfa *  cnfa, struct colormap *  cm, struct smalldfa *  sml  )

static

Referenced by cfind(), find(), getladfa(), and getsubdfa().

pg_regexec()

int pg_regexec	(	regex_t *	re,
		const chr *	string,
		size_t	len,
		size_t	search_start,
		rm_detail_t *	details,
		size_t	nmatch,
		regmatch_t	pmatch[],
		int	flags
	)

Definition at line 185 of file regexec.c.

{
    struct vars var;
    struct vars *v = &var;
    int         st;
    size_t      n;
    size_t      i;
    int         backref;
 
#define  LOCALMAT    20
    regmatch_t  mat[LOCALMAT];
 
#define  LOCALDFAS   40
    struct dfa *subdfas[LOCALDFAS];
 
    /* sanity checks */
    if (re == NULL || string == NULL || re->re_magic != REMAGIC)
        return REG_INVARG;
    if (re->re_csize != sizeof(chr))
        return REG_MIXED;
    if (search_start > len)
        return REG_NOMATCH;
 
    /* Initialize locale-dependent support */
    pg_set_regex_collation(re->re_collation);
 
    /* setup */
    v->re = re;
    v->g = (struct guts *) re->re_guts;
    if ((v->g->cflags & REG_EXPECT) && details == NULL)
        return REG_INVARG;
    if (v->g->info & REG_UIMPOSSIBLE)
        return REG_NOMATCH;
    backref = (v->g->info & REG_UBACKREF) ? 1 : 0;
    v->eflags = flags;
    if (backref && nmatch <= v->g->nsub)
    {
        /* need larger work area */
        v->nmatch = v->g->nsub + 1;
        if (v->nmatch <= LOCALMAT)
            v->pmatch = mat;
        else
            v->pmatch = (regmatch_t *) MALLOC(v->nmatch * sizeof(regmatch_t));
        if (v->pmatch == NULL)
            return REG_ESPACE;
        zapallsubs(v->pmatch, v->nmatch);
    }
    else
    {
        /* we can store results directly in caller's array */
        v->pmatch = pmatch;
        /* ensure any extra entries in caller's array are filled with -1 */
        if (nmatch > 0)
            zapallsubs(pmatch, nmatch);
        /* then forget about extra entries, to avoid useless work in find() */
        if (nmatch > v->g->nsub + 1)
            nmatch = v->g->nsub + 1;
        v->nmatch = nmatch;
    }
    v->details = details;
    v->start = (chr *) string;
    v->search_start = (chr *) string + search_start;
    v->stop = (chr *) string + len;
    v->err = 0;
    v->subdfas = NULL;
    v->ladfas = NULL;
    v->lblastcss = NULL;
    v->lblastcp = NULL;
    /* below this point, "goto cleanup" will behave sanely */
 
    assert(v->g->ntree >= 0);
    n = (size_t) v->g->ntree;
    if (n <= LOCALDFAS)
        v->subdfas = subdfas;
    else
    {
        v->subdfas = (struct dfa **) MALLOC(n * sizeof(struct dfa *));
        if (v->subdfas == NULL)
        {
            st = REG_ESPACE;
            goto cleanup;
        }
    }
    for (i = 0; i < n; i++)
        v->subdfas[i] = NULL;
 
    assert(v->g->nlacons >= 0);
    n = (size_t) v->g->nlacons;
    if (n > 0)
    {
        v->ladfas = (struct dfa **) MALLOC(n * sizeof(struct dfa *));
        if (v->ladfas == NULL)
        {
            st = REG_ESPACE;
            goto cleanup;
        }
        for (i = 0; i < n; i++)
            v->ladfas[i] = NULL;
        v->lblastcss = (struct sset **) MALLOC(n * sizeof(struct sset *));
        v->lblastcp = (chr **) MALLOC(n * sizeof(chr *));
        if (v->lblastcss == NULL || v->lblastcp == NULL)
        {
            st = REG_ESPACE;
            goto cleanup;
        }
        for (i = 0; i < n; i++)
        {
            v->lblastcss[i] = NULL;
            v->lblastcp[i] = NULL;
        }
    }
 
    /* do it */
    assert(v->g->tree != NULL);
    if (backref)
        st = cfind(v, &v->g->tree->cnfa, &v->g->cmap);
    else
        st = find(v, &v->g->tree->cnfa, &v->g->cmap);
 
    /* on success, ensure caller's match vector is filled correctly */
    if (st == REG_OKAY && nmatch > 0)
    {
        if (v->pmatch != pmatch)
        {
            /* copy portion of match vector over from (larger) work area */
            assert(nmatch <= v->nmatch);
            memcpy(VS(pmatch), VS(v->pmatch), nmatch * sizeof(regmatch_t));
        }
        if (v->g->cflags & REG_NOSUB)
        {
            /* don't expose possibly-partial sub-match results to caller */
            zapallsubs(pmatch, nmatch);
        }
    }
 
    /* clean up */
cleanup:
    if (v->pmatch != pmatch && v->pmatch != mat)
        FREE(v->pmatch);
    if (v->subdfas != NULL)
    {
        n = (size_t) v->g->ntree;
        for (i = 0; i < n; i++)
        {
            if (v->subdfas[i] != NULL)
                freedfa(v->subdfas[i]);
        }
        if (v->subdfas != subdfas)
            FREE(v->subdfas);
    }
    if (v->ladfas != NULL)
    {
        n = (size_t) v->g->nlacons;
        for (i = 0; i < n; i++)
        {
            if (v->ladfas[i] != NULL)
                freedfa(v->ladfas[i]);
        }
        FREE(v->ladfas);
    }
    if (v->lblastcss != NULL)
        FREE(v->lblastcss);
    if (v->lblastcp != NULL)
        FREE(v->lblastcp);
 
#ifdef REG_DEBUG
    if (v->eflags & (REG_FTRACE | REG_MTRACE))
        fflush(stdout);
#endif
 
    return st;
}

References assert, cfind(), guts::cflags, cleanup(), guts::cmap, subre::cnfa, vars::details, vars::eflags, vars::err, fflush(), find(), for(), FREE, freedfa(), vars::g, i, if(), guts::info, vars::ladfas, vars::lblastcp, vars::lblastcss, len, LOCALDFAS, LOCALMAT, MALLOC, guts::nlacons, vars::nmatch, guts::nsub, guts::ntree, pg_set_regex_collation(), vars::pmatch, vars::re, regex_t::re_collation, regex_t::re_csize, regex_t::re_guts, regex_t::re_magic, REG_ESPACE, REG_EXPECT, REG_FTRACE, REG_INVARG, REG_MIXED, REG_MTRACE, REG_NOMATCH, REG_NOSUB, REG_OKAY, REG_UBACKREF, REG_UIMPOSSIBLE, REMAGIC, vars::search_start, vars::start, generate_unaccent_rules::stdout, vars::stop, vars::subdfas, guts::tree, VS, and zapallsubs().

Referenced by CheckAffix(), RE_wchar_execute(), regexec_auth_token(), replace_text_regexp(), and test_re_execute().

pickss()

static struct sset* pickss ( struct vars *  v, struct dfa *  d, chr *  cp, chr *  start  )

static

shortest()

static chr* shortest ( struct vars *  v, struct dfa *  d, chr *  start, chr *  min, chr *  max, chr **  coldp, int *  hitstopp  )

static

Referenced by cfindloop(), crevcondissect(), creviterdissect(), and find().

subset()

static void subset ( struct vars *  v, struct subre *  sub, chr *  begin, chr *  end  )

static

Definition at line 702 of file regexec.c.

{
    int         n = sub->capno;
 
    assert(n > 0);
    if ((size_t) n >= v->nmatch)
        return;
 
    MDEBUG(("%d: setting %d = %ld-%ld\n", sub->id, n, LOFF(begin), LOFF(end)));
    v->pmatch[n].rm_so = OFF(begin);
    v->pmatch[n].rm_eo = OFF(end);
}

References assert, subre::begin, subre::capno, subre::end, subre::id, LOFF, MDEBUG, vars::nmatch, OFF, vars::pmatch, regmatch_t::rm_eo, and regmatch_t::rm_so.

Referenced by cdissect().

zapallsubs()

static void zapallsubs ( regmatch_t *  p, size_t  n  )

static

Definition at line 663 of file regexec.c.

{
    size_t      i;
 
    for (i = n - 1; i > 0; i--)
    {
        p[i].rm_so = -1;
        p[i].rm_eo = -1;
    }
}

References i, regmatch_t::rm_eo, and regmatch_t::rm_so.

Referenced by pg_regexec().

zaptreesubs()

static void zaptreesubs ( struct vars *  v, struct subre *  t  )

static

Definition at line 679 of file regexec.c.

{
    int         n = t->capno;
    struct subre *t2;
 
    if (n > 0)
    {
        if ((size_t) n < v->nmatch)
        {
            v->pmatch[n].rm_so = -1;
            v->pmatch[n].rm_eo = -1;
        }
    }
 
    for (t2 = t->child; t2 != NULL; t2 = t2->sibling)
        zaptreesubs(v, t2);
}

References subre::capno, subre::child, vars::pmatch, regmatch_t::rm_eo, regmatch_t::rm_so, and subre::sibling.

Referenced by ccondissect(), citerdissect(), crevcondissect(), and creviterdissect().