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

Include dependency graph for regexec.c:

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))

hash

static unsigned hash(unsigned *uv, int n)

VS

#define VS(x)

Definition: regguts.h:61

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, 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(), cdissect(), 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(), cdissect(), 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, pg_regmatch_t::rm_eo, rm_detail_t::rm_extend, pg_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, 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, pg_regmatch_t::rm_eo, rm_detail_t::rm_extend, pg_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, 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, REG_ESPACE, REG_EXPECT, REG_FTRACE, REG_INVARG, REG_MIXED, REG_MTRACE, REG_NOMATCH, REG_NOSUB, REG_OKAY, REG_UBACKREF, REG_UIMPOSSIBLE, regmatch_t, 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, and vars::pmatch.

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.

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, subre::sibling, and zaptreesubs().

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

Data Structures

Macros

Functions

Macro Definition Documentation

◆ DOMALLOC

◆ ERR

◆ FEWCOLORS

◆ FEWSTATES

◆ HASH

◆ HIT

◆ ISERR

◆ LOCALDFAS

◆ LOCALMAT

◆ LOCKED

◆ LOFF

◆ NOERR

◆ NOPROGRESS

◆ OFF

◆ POSTSTATE

◆ STARTER

◆ VERR

◆ VISERR

◆ WORK

Function Documentation

◆ caltdissect()

◆ cbrdissect()

◆ ccondissect()

◆ cdissect()

◆ cfind()

◆ cfindloop()

◆ citerdissect()

◆ crevcondissect()

◆ creviterdissect()

◆ dfa_backref()

◆ find()

◆ freedfa()

◆ getladfa()

◆ getsubdfa()

◆ getvacant()

◆ hash()

◆ initialize()

◆ lacon()

◆ lastcold()

◆ longest()

◆ matchuntil()

◆ miss()

◆ newdfa()

◆ pg_regexec()

◆ pickss()

◆ shortest()

◆ subset()

◆ zapallsubs()

◆ zaptreesubs()