regcomp.c File Reference

#include "regex/regguts.h"
#include "regc_lex.c"
#include "regc_color.c"
#include "regc_nfa.c"
#include "regc_cvec.c"
#include "regc_pg_locale.c"
#include "regc_locale.c"

Include dependency graph for regcomp.c:

Go to the source code of this file.

Data Structures
struct	vars

Macros
#define	INCOMPATIBLE   1 /* destroys arc */
#define	SATISFIED   2 /* constraint satisfied */
#define	COMPATIBLE   3 /* compatible but not satisfied yet */
#define	REPLACEARC   4 /* replace arc's color with constraint color */
#define	NEXT()   (next(v)) /* advance by one token */
#define	SEE(t)   (v->nexttype == (t)) /* is next token this? */
#define	EAT(t)   (SEE(t) && next(v)) /* if next is this, swallow it */
#define	VISERR(vv)   ((vv)->err != 0) /* have we seen an error yet? */
#define	ISERR()   VISERR(v)
#define	VERR(vv, e)
#define	ERR(e)   VERR(v, e) /* record an error */
#define	NOERR()   {if (ISERR()) return;} /* if error seen, return */
#define	NOERRN()   {if (ISERR()) return NULL;} /* NOERR with retval */
#define	NOERRZ()   {if (ISERR()) return 0;} /* NOERR with retval */
#define	INSIST(c, e)   do { if (!(c)) ERR(e); } while (0) /* error if c false */
#define	NOTE(b)   (v->re->re_info |= (b)) /* note visible condition */
#define	EMPTYARC(x, y)   newarc(v->nfa, EMPTY, 0, x, y)
#define	EMPTY   'n' /* no token present */
#define	EOS   'e' /* end of string */
#define	PLAIN   'p' /* ordinary character */
#define	DIGIT   'd' /* digit (in bound) */
#define	BACKREF   'b' /* back reference */
#define	COLLEL   'I' /* start of [. */
#define	ECLASS   'E' /* start of [= */
#define	CCLASS   'C' /* start of [: */
#define	END   'X' /* end of [. [= [: */
#define	CCLASSS   's' /* char class shorthand escape */
#define	CCLASSC   'c' /* complement char class shorthand escape */
#define	RANGE   'R' /* - within [] which might be range delim. */
#define	LACON   'L' /* lookaround constraint subRE */
#define	AHEAD   'a' /* color-lookahead arc */
#define	BEHIND   'r' /* color-lookbehind arc */
#define	WBDRY   'w' /* word boundary constraint */
#define	NWBDRY   'W' /* non-word-boundary constraint */
#define	SBEGIN   'A' /* beginning of string (even if not BOL) */
#define	SEND   'Z' /* end of string (even if not EOL) */
#define	COLORED(a)
#define	CNOERR()   { if (ISERR()) return freev(v, v->err); }
#define	ARCV(t, val)   newarc(v->nfa, t, val, lp, rp)
#define	SOME   2
#define	INF   3
#define	PAIR(x, y)   ((x)*4 + (y))
#define	REDUCE(x)   ( ((x) == DUPINF) ? INF : (((x) > 1) ? SOME : (x)) )

Functions
static void	moresubs (struct vars *, int)
static int	freev (struct vars *, int)
static void	makesearch (struct vars *, struct nfa *)
static struct subre *	parse (struct vars *, int, int, struct state *, struct state *)
static struct subre *	parsebranch (struct vars *, int, int, struct state *, struct state *, int)
static struct subre *	parseqatom (struct vars *, int, int, struct state *, struct state *, struct subre *)
static void	nonword (struct vars *, int, struct state *, struct state *)
static void	word (struct vars *, int, struct state *, struct state *)
static void	charclass (struct vars *, enum char_classes, struct state *, struct state *)
static void	charclasscomplement (struct vars *, enum char_classes, struct state *, struct state *)
static int	scannum (struct vars *)
static void	repeat (struct vars *, struct state *, struct state *, int, int)
static void	bracket (struct vars *, struct state *, struct state *)
static void	cbracket (struct vars *, struct state *, struct state *)
static void	brackpart (struct vars *, struct state *, struct state *, bool *)
static const chr *	scanplain (struct vars *)
static void	onechr (struct vars *, chr, struct state *, struct state *)
static void	optimizebracket (struct vars *, struct state *, struct state *)
static void	wordchrs (struct vars *)
static void	processlacon (struct vars *, struct state *, struct state *, int, struct state *, struct state *)
static struct subre *	subre (struct vars *, int, int, struct state *, struct state *)
static void	freesubre (struct vars *, struct subre *)
static void	freesubreandsiblings (struct vars *, struct subre *)
static void	freesrnode (struct vars *, struct subre *)
static void	removecaptures (struct vars *, struct subre *)
static int	numst (struct subre *, int)
static void	markst (struct subre *)
static void	cleanst (struct vars *)
static long	nfatree (struct vars *, struct subre *, FILE *)
static long	nfanode (struct vars *, struct subre *, int, FILE *)
static int	newlacon (struct vars *, struct state *, struct state *, int)
static void	freelacons (struct subre *, int)
static void	rfree (regex_t *)
static int	rcancelrequested (void)
static int	rstacktoodeep (void)
static void	lexstart (struct vars *)
static void	prefixes (struct vars *)
static int	next (struct vars *)
static int	lexescape (struct vars *)
static chr	lexdigits (struct vars *, int, int, int)
static int	brenext (struct vars *, chr)
static void	skip (struct vars *)
static chr	newline (void)
static chr	chrnamed (struct vars *, const chr *, const chr *, chr)
static void	initcm (struct vars *, struct colormap *)
static void	freecm (struct colormap *)
static color	maxcolor (struct colormap *)
static color	newcolor (struct colormap *)
static void	freecolor (struct colormap *, color)
static color	pseudocolor (struct colormap *)
static color	subcolor (struct colormap *, chr)
static color	subcolorhi (struct colormap *, color *)
static color	newsub (struct colormap *, color)
static int	newhicolorrow (struct colormap *, int)
static void	newhicolorcols (struct colormap *)
static void	subcolorcvec (struct vars *, struct cvec *, struct state *, struct state *)
static void	subcoloronechr (struct vars *, chr, struct state *, struct state *, color *)
static void	subcoloronerange (struct vars *, chr, chr, struct state *, struct state *, color *)
static void	subcoloronerow (struct vars *, int, struct state *, struct state *, color *)
static void	okcolors (struct nfa *, struct colormap *)
static void	colorchain (struct colormap *, struct arc *)
static void	uncolorchain (struct colormap *, struct arc *)
static void	rainbow (struct nfa *, struct colormap *, int, color, struct state *, struct state *)
static void	colorcomplement (struct nfa *, struct colormap *, int, struct state *, struct state *, struct state *)
static struct nfa *	newnfa (struct vars *, struct colormap *, struct nfa *)
static void	freenfa (struct nfa *)
static struct state *	newstate (struct nfa *)
static struct state *	newfstate (struct nfa *, int flag)
static void	dropstate (struct nfa *, struct state *)
static void	freestate (struct nfa *, struct state *)
static void	newarc (struct nfa *, int, color, struct state *, struct state *)
static void	createarc (struct nfa *, int, color, struct state *, struct state *)
static struct arc *	allocarc (struct nfa *)
static void	freearc (struct nfa *, struct arc *)
static void	changearcsource (struct arc *, struct state *)
static void	changearctarget (struct arc *, struct state *)
static int	hasnonemptyout (struct state *)
static struct arc *	findarc (struct state *, int, color)
static void	cparc (struct nfa *, struct arc *, struct state *, struct state *)
static void	sortins (struct nfa *, struct state *)
static int	sortins_cmp (const void *, const void *)
static void	sortouts (struct nfa *, struct state *)
static int	sortouts_cmp (const void *, const void *)
static void	moveins (struct nfa *, struct state *, struct state *)
static void	copyins (struct nfa *, struct state *, struct state *)
static void	mergeins (struct nfa *, struct state *, struct arc **, int)
static void	moveouts (struct nfa *, struct state *, struct state *)
static void	copyouts (struct nfa *, struct state *, struct state *)
static void	cloneouts (struct nfa *, struct state *, struct state *, struct state *, int)
static void	delsub (struct nfa *, struct state *, struct state *)
static void	deltraverse (struct nfa *, struct state *, struct state *)
static void	dupnfa (struct nfa *, struct state *, struct state *, struct state *, struct state *)
static void	duptraverse (struct nfa *, struct state *, struct state *)
static void	removeconstraints (struct nfa *, struct state *, struct state *)
static void	removetraverse (struct nfa *, struct state *)
static void	cleartraverse (struct nfa *, struct state *)
static struct state *	single_color_transition (struct state *, struct state *)
static void	specialcolors (struct nfa *)
static long	optimize (struct nfa *, FILE *)
static void	pullback (struct nfa *, FILE *)
static int	pull (struct nfa *, struct arc *, struct state **)
static void	pushfwd (struct nfa *, FILE *)
static int	push (struct nfa *, struct arc *, struct state **)
static int	combine (struct nfa *nfa, struct arc *con, struct arc *a)
static void	fixempties (struct nfa *, FILE *)
static struct state *	emptyreachable (struct nfa *, struct state *, struct state *, struct arc **)
static int	isconstraintarc (struct arc *)
static int	hasconstraintout (struct state *)
static void	fixconstraintloops (struct nfa *, FILE *)
static int	findconstraintloop (struct nfa *, struct state *)
static void	breakconstraintloop (struct nfa *, struct state *)
static void	clonesuccessorstates (struct nfa *, struct state *, struct state *, struct state *, struct arc *, char *, char *, int)
static void	cleanup (struct nfa *)
static void	markreachable (struct nfa *, struct state *, struct state *, struct state *)
static void	markcanreach (struct nfa *, struct state *, struct state *, struct state *)
static long	analyze (struct nfa *)
static void	checkmatchall (struct nfa *)
static bool	checkmatchall_recurse (struct nfa *, struct state *, bool **)
static bool	check_out_colors_match (struct state *, color, color)
static bool	check_in_colors_match (struct state *, color, color)
static void	compact (struct nfa *, struct cnfa *)
static void	carcsort (struct carc *, size_t)
static int	carc_cmp (const void *, const void *)
static void	freecnfa (struct cnfa *)
static void	dumpnfa (struct nfa *, FILE *)
static struct cvec *	newcvec (int, int)
static struct cvec *	clearcvec (struct cvec *)
static void	addchr (struct cvec *, chr)
static void	addrange (struct cvec *, chr, chr)
static struct cvec *	getcvec (struct vars *, int, int)
static void	freecvec (struct cvec *)
static int	pg_wc_isdigit (pg_wchar c)
static int	pg_wc_isalpha (pg_wchar c)
static int	pg_wc_isalnum (pg_wchar c)
static int	pg_wc_isword (pg_wchar c)
static int	pg_wc_isupper (pg_wchar c)
static int	pg_wc_islower (pg_wchar c)
static int	pg_wc_isgraph (pg_wchar c)
static int	pg_wc_isprint (pg_wchar c)
static int	pg_wc_ispunct (pg_wchar c)
static int	pg_wc_isspace (pg_wchar c)
static pg_wchar	pg_wc_toupper (pg_wchar c)
static pg_wchar	pg_wc_tolower (pg_wchar c)
static chr	element (struct vars *, const chr *, const chr *)
static struct cvec *	range (struct vars *, chr, chr, int)
static int	before (chr, chr)
static struct cvec *	eclass (struct vars *, chr, int)
static enum char_classes	lookupcclass (struct vars *, const chr *, const chr *)
static struct cvec *	cclasscvec (struct vars *, enum char_classes, int)
static int	cclass_column_index (struct colormap *, chr)
static struct cvec *	allcases (struct vars *, chr)
static int	cmp (const chr *, const chr *, size_t)
static int	casecmp (const chr *, const chr *, size_t)
int	pg_regcomp (regex_t *re, const chr *string, size_t len, int flags, Oid collation)

Variables
static const struct fns	functions

Macro Definition Documentation

AHEAD

#define AHEAD   'a' /* color-lookahead arc */

Definition at line 298 of file regcomp.c.

ARCV

#define ARCV	(		t,
			val
	)		newarc(v->nfa, t, val, lp, rp)

BACKREF

#define BACKREF   'b' /* back reference */

Definition at line 289 of file regcomp.c.

BEHIND

#define BEHIND   'r' /* color-lookbehind arc */

Definition at line 299 of file regcomp.c.

CCLASS

#define CCLASS   'C' /* start of [: */

Definition at line 292 of file regcomp.c.

CCLASSC

#define CCLASSC   'c' /* complement char class shorthand escape */

Definition at line 295 of file regcomp.c.

CCLASSS

#define CCLASSS   's' /* char class shorthand escape */

Definition at line 294 of file regcomp.c.

CNOERR

#define CNOERR

(

)

{ if (ISERR()) return freev(v, v->err); }

COLLEL

#define COLLEL   'I' /* start of [. */

Definition at line 290 of file regcomp.c.

COLORED

#define COLORED

(

a

)

Value:

    ((a)->co >= 0 && \
     ((a)->type == PLAIN || (a)->type == AHEAD || (a)->type == BEHIND))

Definition at line 307 of file regcomp.c.

COMPATIBLE

#define COMPATIBLE   3 /* compatible but not satisfied yet */

Definition at line 166 of file regcomp.c.

DIGIT

#define DIGIT   'd' /* digit (in bound) */

Definition at line 288 of file regcomp.c.

EAT

#define EAT

(

t

)

(SEE(t) && next(v)) /* if next is this, swallow it */

Definition at line 271 of file regcomp.c.

ECLASS

#define ECLASS   'E' /* start of [= */

Definition at line 291 of file regcomp.c.

EMPTY

#define EMPTY   'n' /* no token present */

Definition at line 285 of file regcomp.c.

EMPTYARC

#define EMPTYARC	(		x,
			y
	)		newarc(v->nfa, EMPTY, 0, x, y)

Definition at line 282 of file regcomp.c.

END

#define END   'X' /* end of [. [= [: */

Definition at line 293 of file regcomp.c.

EOS

#define EOS   'e' /* end of string */

Definition at line 286 of file regcomp.c.

ERR

#define ERR

(

e

)

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

Definition at line 276 of file regcomp.c.

INCOMPATIBLE

#define INCOMPATIBLE   1 /* destroys arc */

Definition at line 164 of file regcomp.c.

INF

#define INF   3

INSIST

#define INSIST	(		c,
			e
	)		do { if (!(c)) ERR(e); } while (0) /* error if c false */

Definition at line 280 of file regcomp.c.

ISERR

#define ISERR

(

)

VISERR(v)

Definition at line 273 of file regcomp.c.

LACON

#define LACON   'L' /* lookaround constraint subRE */

Definition at line 297 of file regcomp.c.

NEXT

#define NEXT

(

)

(next(v)) /* advance by one token */

Definition at line 269 of file regcomp.c.

NOERR

#define NOERR

(

)

{if (ISERR()) return;} /* if error seen, return */

Definition at line 277 of file regcomp.c.

NOERRN

#define NOERRN

(

)

{if (ISERR()) return NULL;} /* NOERR with retval */

Definition at line 278 of file regcomp.c.

NOERRZ

#define NOERRZ

(

)

{if (ISERR()) return 0;} /* NOERR with retval */

Definition at line 279 of file regcomp.c.

NOTE

#define NOTE

(

b

)

(v->re->re_info |= (b)) /* note visible condition */

Definition at line 281 of file regcomp.c.

NWBDRY

#define NWBDRY   'W' /* non-word-boundary constraint */

Definition at line 301 of file regcomp.c.

PAIR

#define PAIR	(		x,
			y
	)		((x)*4 + (y))

PLAIN

#define PLAIN   'p' /* ordinary character */

Definition at line 287 of file regcomp.c.

RANGE

#define RANGE   'R' /* - within [] which might be range delim. */

Definition at line 296 of file regcomp.c.

REDUCE

#define REDUCE

(

x

)

( ((x) == DUPINF) ? INF : (((x) > 1) ? SOME : (x)) )

REPLACEARC

#define REPLACEARC   4 /* replace arc's color with constraint color */

Definition at line 167 of file regcomp.c.

SATISFIED

#define SATISFIED   2 /* constraint satisfied */

Definition at line 165 of file regcomp.c.

SBEGIN

#define SBEGIN   'A' /* beginning of string (even if not BOL) */

Definition at line 302 of file regcomp.c.

SEE

#define SEE

(

t

)

(v->nexttype == (t)) /* is next token this? */

Definition at line 270 of file regcomp.c.

SEND

#define SEND   'Z' /* end of string (even if not EOL) */

Definition at line 303 of file regcomp.c.

SOME

#define SOME   2

VERR

#define VERR	(		vv,
			e
	)

Value:

                     ((vv)->nexttype = EOS, \
                     (vv)->err = ((vv)->err ? (vv)->err : (e)))

Definition at line 274 of file regcomp.c.

VISERR

#define VISERR

(

vv

)

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

Definition at line 272 of file regcomp.c.

WBDRY

#define WBDRY   'w' /* word boundary constraint */

Definition at line 300 of file regcomp.c.

Function Documentation

addchr()

static void addchr ( struct cvec *  , chr    )

static

addrange()

static void addrange ( struct cvec *  , chr  , chr    )

static

allcases()

static struct cvec* allcases ( struct vars *  , chr    )

static

Referenced by onechr().

allocarc()

static struct arc* allocarc ( struct nfa *  )

static

analyze()

static long analyze ( struct nfa *  )

static

before()

static int before ( chr  , chr    )

static

bracket()

static void bracket ( struct vars *  v, struct state *  lp, struct state *  rp  )

static

Definition at line 1629 of file regcomp.c.

{
    /*
     * We can't process complemented char classes (e.g. \W) immediately while
     * scanning the bracket expression, else color bookkeeping gets confused.
     * Instead, remember whether we saw any in have_cclassc[], and process
     * them at the end.
     */
    bool        have_cclassc[NUM_CCLASSES];
    bool        any_cclassc;
    int         i;
 
    memset(have_cclassc, false, sizeof(have_cclassc));
 
    assert(SEE('['));
    NEXT();
    while (!SEE(']') && !SEE(EOS))
        brackpart(v, lp, rp, have_cclassc);
    assert(SEE(']') || ISERR());
 
    /* close up open subcolors from the positive bracket elements */
    okcolors(v->nfa, v->cm);
    NOERR();
 
    /* now handle any complemented elements */
    any_cclassc = false;
    for (i = 0; i < NUM_CCLASSES; i++)
    {
        if (have_cclassc[i])
        {
            charclasscomplement(v, (enum char_classes) i, lp, rp);
            NOERR();
            any_cclassc = true;
        }
    }
 
    /*
     * If we had any complemented elements, see if we can optimize the bracket
     * into a rainbow.  Since a complemented element is the only way a WHITE
     * arc could get into the result, there's no point in checking otherwise.
     */
    if (any_cclassc)
        optimizebracket(v, lp, rp);
}

References assert, brackpart(), charclasscomplement(), vars::cm, EOS, i, ISERR, NEXT, vars::nfa, NOERR, NUM_CCLASSES, okcolors(), optimizebracket(), and SEE.

Referenced by cbracket(), and parseqatom().

brackpart()

static void brackpart ( struct vars *  v, struct state *  lp, struct state *  rp, bool *  have_cclassc  )

static

Definition at line 1719 of file regcomp.c.

{
    chr         startc;
    chr         endc;
    struct cvec *cv;
    enum char_classes cls;
    const chr  *startp;
    const chr  *endp;
 
    /* parse something, get rid of special cases, take shortcuts */
    switch (v->nexttype)
    {
        case RANGE:             /* a-b-c or other botch */
            ERR(REG_ERANGE);
            return;
            break;
        case PLAIN:
            startc = v->nextvalue;
            NEXT();
            /* shortcut for ordinary chr (not range) */
            if (!SEE(RANGE))
            {
                onechr(v, startc, lp, rp);
                return;
            }
            NOERR();
            break;
        case COLLEL:
            startp = v->now;
            endp = scanplain(v);
            INSIST(startp < endp, REG_ECOLLATE);
            NOERR();
            startc = element(v, startp, endp);
            NOERR();
            break;
        case ECLASS:
            startp = v->now;
            endp = scanplain(v);
            INSIST(startp < endp, REG_ECOLLATE);
            NOERR();
            startc = element(v, startp, endp);
            NOERR();
            cv = eclass(v, startc, (v->cflags & REG_ICASE));
            NOERR();
            subcolorcvec(v, cv, lp, rp);
            return;
            break;
        case CCLASS:
            startp = v->now;
            endp = scanplain(v);
            INSIST(startp < endp, REG_ECTYPE);
            NOERR();
            cls = lookupcclass(v, startp, endp);
            NOERR();
            charclass(v, cls, lp, rp);
            return;
            break;
        case CCLASSS:
            charclass(v, (enum char_classes) v->nextvalue, lp, rp);
            NEXT();
            return;
            break;
        case CCLASSC:
            /* we cannot call charclasscomplement() immediately */
            have_cclassc[v->nextvalue] = true;
            NEXT();
            return;
            break;
        default:
            ERR(REG_ASSERT);
            return;
            break;
    }
 
    if (SEE(RANGE))
    {
        NEXT();
        switch (v->nexttype)
        {
            case PLAIN:
            case RANGE:
                endc = v->nextvalue;
                NEXT();
                NOERR();
                break;
            case COLLEL:
                startp = v->now;
                endp = scanplain(v);
                INSIST(startp < endp, REG_ECOLLATE);
                NOERR();
                endc = element(v, startp, endp);
                NOERR();
                break;
            default:
                ERR(REG_ERANGE);
                return;
                break;
        }
    }
    else
        endc = startc;
 
    /*
     * Ranges are unportable.  Actually, standard C does guarantee that digits
     * are contiguous, but making that an exception is just too complicated.
     */
    if (startc != endc)
        NOTE(REG_UUNPORT);
    cv = range(v, startc, endc, (v->cflags & REG_ICASE));
    NOERR();
    subcolorcvec(v, cv, lp, rp);
}

References CCLASS, CCLASSC, CCLASSS, vars::cflags, charclass(), COLLEL, eclass(), ECLASS, element(), ERR, INSIST, lookupcclass(), NEXT, vars::nexttype, vars::nextvalue, NOERR, NOTE, vars::now, onechr(), PLAIN, range(), RANGE, REG_ASSERT, REG_ECOLLATE, REG_ECTYPE, REG_ERANGE, REG_ICASE, REG_UUNPORT, scanplain(), SEE, and subcolorcvec().

Referenced by bracket().

breakconstraintloop()

static void breakconstraintloop ( struct nfa *  , struct state *    )

static

brenext()

static int brenext ( struct vars *  , chr    )

static

carc_cmp()

static int carc_cmp ( const void *  , const void *    )

static

carcsort()

static void carcsort ( struct carc *  , size_t    )

static

casecmp()

static int casecmp ( const chr *  , const chr *  , size_t    )

static

Referenced by pg_regcomp().

cbracket()

static void cbracket ( struct vars *  v, struct state *  lp, struct state *  rp  )

static

Definition at line 1685 of file regcomp.c.

{
    struct state *left = newstate(v->nfa);
    struct state *right = newstate(v->nfa);
 
    NOERR();
    bracket(v, left, right);
 
    /* in NLSTOP mode, ensure newline is not part of the result set */
    if (v->cflags & REG_NLSTOP)
        newarc(v->nfa, PLAIN, v->nlcolor, left, right);
    NOERR();
 
    assert(lp->nouts == 0);     /* all outarcs will be ours */
 
    /*
     * Easy part of complementing, and all there is to do since the MCCE code
     * was removed.  Note that the result of colorcomplement() cannot be a
     * rainbow, since we don't allow empty brackets; so there's no point in
     * calling optimizebracket() again.
     */
    colorcomplement(v->nfa, v->cm, PLAIN, left, lp, rp);
    NOERR();
    dropstate(v->nfa, left);
    assert(right->nins == 0);
    freestate(v->nfa, right);
}

References assert, bracket(), vars::cflags, vars::cm, colorcomplement(), dropstate(), freestate(), newarc(), newstate(), vars::nfa, state::nins, vars::nlcolor, NOERR, state::nouts, PLAIN, and REG_NLSTOP.

Referenced by parseqatom().

cclass_column_index()

static int cclass_column_index ( struct colormap *  , chr    )

static

cclasscvec()

static struct cvec* cclasscvec ( struct vars *  , enum  char_classes, int    )

static

Referenced by charclass(), charclasscomplement(), and wordchrs().

changearcsource()

static void changearcsource ( struct arc *  , struct state *    )

static

changearctarget()

static void changearctarget ( struct arc *  , struct state *    )

static

charclass()

static void charclass ( struct vars *  v, enum char_classes  cls, struct state *  lp, struct state *  rp  )

static

Definition at line 1450 of file regcomp.c.

{
    struct cvec *cv;
 
    /* obtain possibly-cached cvec for char class */
    NOTE(REG_ULOCALE);
    cv = cclasscvec(v, cls, (v->cflags & REG_ICASE));
    NOERR();
 
    /* build the arcs; this may cause color splitting */
    subcolorcvec(v, cv, lp, rp);
}

References cclasscvec(), vars::cflags, NOERR, NOTE, REG_ICASE, REG_ULOCALE, and subcolorcvec().

Referenced by brackpart(), and parseqatom().

charclasscomplement()

static void charclasscomplement ( struct vars *  v, enum char_classes  cls, struct state *  lp, struct state *  rp  )

static

Definition at line 1474 of file regcomp.c.

{
    struct state *cstate;
    struct cvec *cv;
 
    /* make dummy state to hang temporary arcs on */
    cstate = newstate(v->nfa);
    NOERR();
 
    /* obtain possibly-cached cvec for char class */
    NOTE(REG_ULOCALE);
    cv = cclasscvec(v, cls, (v->cflags & REG_ICASE));
    NOERR();
 
    /* build arcs for char class; this may cause color splitting */
    subcolorcvec(v, cv, cstate, cstate);
    NOERR();
 
    /* clean up any subcolors in the arc set */
    okcolors(v->nfa, v->cm);
    NOERR();
 
    /* now build output arcs for the complement of the char class */
    colorcomplement(v->nfa, v->cm, PLAIN, cstate, lp, rp);
    NOERR();
 
    /* clean up dummy state */
    dropstate(v->nfa, cstate);
}

References cclasscvec(), vars::cflags, vars::cm, colorcomplement(), dropstate(), newstate(), vars::nfa, NOERR, NOTE, okcolors(), PLAIN, REG_ICASE, REG_ULOCALE, and subcolorcvec().

Referenced by bracket(), and parseqatom().

check_in_colors_match()

static bool check_in_colors_match ( struct state *  , color  , color    )

static

check_out_colors_match()

static bool check_out_colors_match ( struct state *  , color  , color    )

static

checkmatchall()

static void checkmatchall ( struct nfa *  )

static

checkmatchall_recurse()

static bool checkmatchall_recurse ( struct nfa *  , struct state *  , bool **    )

static

chrnamed()

static chr chrnamed ( struct vars *  , const chr *  , const chr *  , chr    )

static

cleanst()

static void cleanst ( struct vars *  v )

static

Definition at line 2268 of file regcomp.c.

{
    struct subre *t;
    struct subre *next;
 
    for (t = v->treechain; t != NULL; t = next)
    {
        next = t->chain;
        if (!(t->flags & INUSE))
            FREE(t);
    }
    v->treechain = NULL;
    v->treefree = NULL;         /* just on general principles */
}

References subre::chain, subre::flags, FREE, INUSE, next(), vars::treechain, and vars::treefree.

Referenced by freev(), and pg_regcomp().

cleanup()

static void cleanup ( struct nfa *  )

static

clearcvec()

static struct cvec* clearcvec ( struct cvec *  )

static

cleartraverse()

static void cleartraverse ( struct nfa *  , struct state *    )

static

cloneouts()

static void cloneouts ( struct nfa *  , struct state *  , struct state *  , struct state *  , int    )

static

Referenced by processlacon(), and word().

clonesuccessorstates()

static void clonesuccessorstates ( struct nfa *  , struct state *  , struct state *  , struct state *  , struct arc *  , char *  , char *  , int    )

static

cmp()

static int cmp ( const chr *  , const chr *  , size_t    )

static

Referenced by pg_regcomp().

colorchain()

static void colorchain ( struct colormap *  , struct arc *    )

static

colorcomplement()

static void colorcomplement ( struct nfa *  , struct colormap *  , int  , struct state *  , struct state *  , struct state *    )

static

Referenced by cbracket(), charclasscomplement(), nonword(), and processlacon().

combine()

static int combine ( struct nfa *  nfa, struct arc *  con, struct arc *  a  )

static

compact()

static void compact ( struct nfa *  , struct cnfa *    )

static

Referenced by nfanode(), and pg_regcomp().

copyins()

static void copyins ( struct nfa *  , struct state *  , struct state *    )

static

copyouts()

static void copyouts ( struct nfa *  , struct state *  , struct state *    )

static

Referenced by makesearch().

cparc()

static void cparc ( struct nfa *  , struct arc *  , struct state *  , struct state *    )

static

Referenced by makesearch().

createarc()

static void createarc ( struct nfa *  , int  , color  , struct state *  , struct state *    )

static

delsub()

static void delsub ( struct nfa *  , struct state *  , struct state *    )

static

Referenced by parseqatom(), and repeat().

deltraverse()

static void deltraverse ( struct nfa *  , struct state *  , struct state *    )

static

dropstate()

static void dropstate ( struct nfa *  , struct state *    )

static

Referenced by cbracket(), and charclasscomplement().

dumpnfa()

static void dumpnfa ( struct nfa *  , FILE *    )

static

Referenced by pg_regcomp().

dupnfa()

static void dupnfa ( struct nfa *  , struct state *  , struct state *  , struct state *  , struct state *    )

static

Referenced by nfanode(), parseqatom(), and repeat().

duptraverse()

static void duptraverse ( struct nfa *  , struct state *  , struct state *    )

static

eclass()

static struct cvec* eclass ( struct vars *  , chr  , int    )

static

Referenced by brackpart().

element()

static chr element ( struct vars *  , const chr *  , const chr *    )

static

Referenced by brackpart().

emptyreachable()

static struct state* emptyreachable ( struct nfa *  , struct state *  , struct state *  , struct arc **    )

static

findarc()

static struct arc* findarc ( struct state *  , int  , color    )

static

findconstraintloop()

static int findconstraintloop ( struct nfa *  , struct state *    )

static

fixconstraintloops()

static void fixconstraintloops ( struct nfa *  , FILE *    )

static

fixempties()

static void fixempties ( struct nfa *  , FILE *    )

static

freearc()

static void freearc ( struct nfa *  , struct arc *    )

static

Referenced by makesearch(), and optimizebracket().

freecm()

static void freecm ( struct colormap *  )

static

Referenced by rfree().

freecnfa()

static void freecnfa ( struct cnfa *  )

static

Referenced by freelacons(), freesrnode(), and rfree().

freecolor()

static void freecolor ( struct colormap *  , color    )

static

freecvec()

static void freecvec ( struct cvec *  )

static

Referenced by freev().

freelacons()

static void freelacons ( struct subre *  subs, int  n  )

static

Definition at line 2385 of file regcomp.c.

{
    struct subre *sub;
    int         i;
 
    assert(n > 0);
    for (sub = subs + 1, i = n - 1; i > 0; sub++, i--)  /* no 0th */
        if (!NULLCNFA(sub->cnfa))
            freecnfa(&sub->cnfa);
    FREE(subs);
}

References assert, subre::cnfa, FREE, freecnfa(), i, and NULLCNFA.

Referenced by freev(), and rfree().

freenfa()

static void freenfa ( struct nfa *  )

static

Referenced by freev(), and nfanode().

freesrnode()

static void freesrnode ( struct vars *  v, struct subre *  sr  )

static

Definition at line 2143 of file regcomp.c.

{
    if (sr == NULL)
        return;
 
    if (!NULLCNFA(sr->cnfa))
        freecnfa(&sr->cnfa);
    sr->flags = 0;              /* in particular, not INUSE */
    sr->child = sr->sibling = NULL;
    sr->begin = sr->end = NULL;
 
    if (v != NULL && v->treechain != NULL)
    {
        /* we're still parsing, maybe we can reuse the subre */
        sr->child = v->treefree;
        v->treefree = sr;
    }
    else
        FREE(sr);
}

References subre::begin, subre::child, subre::cnfa, subre::end, subre::flags, FREE, freecnfa(), NULLCNFA, subre::sibling, vars::treechain, and vars::treefree.

Referenced by freesubre(), parse(), and parseqatom().

freestate()

static void freestate ( struct nfa *  , struct state *    )

static

Referenced by cbracket().

freesubre()

static void freesubre ( struct vars *  v, struct subre *  sr  )

static

Definition at line 2108 of file regcomp.c.

{
    if (sr == NULL)
        return;
 
    if (sr->child != NULL)
        freesubreandsiblings(v, sr->child);
 
    freesrnode(v, sr);
}

References subre::child, freesrnode(), and freesubreandsiblings().

Referenced by freesubreandsiblings(), freev(), parseqatom(), and rfree().

freesubreandsiblings()

static void freesubreandsiblings ( struct vars *  v, struct subre *  sr  )

static

Definition at line 2127 of file regcomp.c.

{
    while (sr != NULL)
    {
        struct subre *next = sr->sibling;
 
        freesubre(v, sr);
        sr = next;
    }
}

References freesubre(), next(), and subre::sibling.

Referenced by freesubre(), parse(), parseqatom(), and removecaptures().

freev()

static int freev ( struct vars *  v, int  err  )

static

Definition at line 548 of file regcomp.c.

{
    if (v->re != NULL)
        rfree(v->re);
    if (v->subs != v->sub10)
        FREE(v->subs);
    if (v->nfa != NULL)
        freenfa(v->nfa);
    if (v->tree != NULL)
        freesubre(v, v->tree);
    if (v->treechain != NULL)
        cleanst(v);
    if (v->cv != NULL)
        freecvec(v->cv);
    if (v->cv2 != NULL)
        freecvec(v->cv2);
    if (v->lacons != NULL)
        freelacons(v->lacons, v->nlacons);
    ERR(err);                   /* nop if err==0 */
 
    return v->err;
}

References cleanst(), vars::cv, vars::cv2, vars::err, ERR, FREE, freecvec(), freelacons(), freenfa(), freesubre(), vars::lacons, vars::nfa, vars::nlacons, vars::re, rfree(), vars::sub10, vars::subs, vars::tree, and vars::treechain.

Referenced by pg_regcomp().

getcvec()

static struct cvec* getcvec ( struct vars *  , int  , int    )

static

hasconstraintout()

static int hasconstraintout ( struct state *  )

static

hasnonemptyout()

static int hasnonemptyout ( struct state *  )

static

initcm()

static void initcm ( struct vars *  , struct colormap *    )

static

Referenced by pg_regcomp().

isconstraintarc()

static int isconstraintarc ( struct arc *  )

static

lexdigits()

static chr lexdigits ( struct vars *  , int  , int  , int    )

static

lexescape()

static int lexescape ( struct vars *  )

static

lexstart()

static void lexstart ( struct vars *  )

static

Referenced by pg_regcomp().

lookupcclass()

static enum char_classes lookupcclass ( struct vars *  , const chr *  , const chr *    )

static

Referenced by brackpart().

makesearch()

static void makesearch ( struct vars *  v, struct nfa *  nfa  )

static

Definition at line 577 of file regcomp.c.

{
    struct arc *a;
    struct arc *b;
    struct state *pre = nfa->pre;
    struct state *s;
    struct state *s2;
    struct state *slist;
 
    /* no loops are needed if it's anchored */
    for (a = pre->outs; a != NULL; a = a->outchain)
    {
        assert(a->type == PLAIN);
        if (a->co != nfa->bos[0] && a->co != nfa->bos[1])
            break;
    }
    if (a != NULL)
    {
        /* add implicit .* in front */
        rainbow(nfa, v->cm, PLAIN, COLORLESS, pre, pre);
 
        /* and ^* and \A* too -- not always necessary, but harmless */
        newarc(nfa, PLAIN, nfa->bos[0], pre, pre);
        newarc(nfa, PLAIN, nfa->bos[1], pre, pre);
 
        /*
         * The pattern is still MATCHALL if it was before, but the max match
         * length is now infinity.
         */
        if (nfa->flags & MATCHALL)
            nfa->maxmatchall = DUPINF;
    }
 
    /*
     * Now here's the subtle part.  Because many REs have no lookback
     * constraints, often knowing when you were in the pre state tells you
     * little; it's the next state(s) that are informative.  But some of them
     * may have other inarcs, i.e. it may be possible to make actual progress
     * and then return to one of them.  We must de-optimize such cases,
     * splitting each such state into progress and no-progress states.
     */
 
    /* first, make a list of the states reachable from pre and elsewhere */
    slist = NULL;
    for (a = pre->outs; a != NULL; a = a->outchain)
    {
        s = a->to;
        for (b = s->ins; b != NULL; b = b->inchain)
        {
            if (b->from != pre)
                break;
        }
 
        /*
         * We want to mark states as being in the list already by having non
         * NULL tmp fields, but we can't just store the old slist value in tmp
         * because that doesn't work for the first such state.  Instead, the
         * first list entry gets its own address in tmp.
         */
        if (b != NULL && s->tmp == NULL)
        {
            s->tmp = (slist != NULL) ? slist : s;
            slist = s;
        }
    }
 
    /* do the splits */
    for (s = slist; s != NULL; s = s2)
    {
        s2 = newstate(nfa);
        NOERR();
        copyouts(nfa, s, s2);
        NOERR();
        for (a = s->ins; a != NULL; a = b)
        {
            b = a->inchain;
            if (a->from != pre)
            {
                cparc(nfa, a, a->from, s2);
                freearc(nfa, a);
            }
        }
        s2 = (s->tmp != s) ? s->tmp : NULL;
        s->tmp = NULL;          /* clean up while we're at it */
    }
}

References a, assert, b, nfa::bos, vars::cm, COLORLESS, copyouts(), cparc(), DUPINF, nfa::flags, freearc(), state::ins, MATCHALL, nfa::maxmatchall, newarc(), newstate(), NOERR, state::outs, PLAIN, nfa::pre, rainbow(), s2, and state::tmp.

Referenced by nfanode(), and pg_regcomp().

markcanreach()

static void markcanreach ( struct nfa *  , struct state *  , struct state *  , struct state *    )

static

markreachable()

static void markreachable ( struct nfa *  , struct state *  , struct state *  , struct state *    )

static

markst()

static void markst ( struct subre *  t )

static

Definition at line 2253 of file regcomp.c.

{
    struct subre *t2;
 
    assert(t != NULL);
 
    t->flags |= INUSE;
    for (t2 = t->child; t2 != NULL; t2 = t2->sibling)
        markst(t2);
}

References assert, subre::child, subre::flags, INUSE, and subre::sibling.

Referenced by pg_regcomp().

maxcolor()

static color maxcolor ( struct colormap *  )

static

mergeins()

static void mergeins ( struct nfa *  , struct state *  , struct arc **  , int    )

static

moresubs()

static void moresubs ( struct vars *  v, int  wanted  )

static

Definition at line 511 of file regcomp.c.

{
    struct subre **p;
    size_t      n;
 
    assert(wanted > 0 && (size_t) wanted >= v->nsubs);
    n = (size_t) wanted * 3 / 2 + 1;
 
    if (v->subs == v->sub10)
    {
        p = (struct subre **) MALLOC(n * sizeof(struct subre *));
        if (p != NULL)
            memcpy(VS(p), VS(v->subs),
                   v->nsubs * sizeof(struct subre *));
    }
    else
        p = (struct subre **) REALLOC(v->subs, n * sizeof(struct subre *));
    if (p == NULL)
    {
        ERR(REG_ESPACE);
        return;
    }
    v->subs = p;
    for (p = &v->subs[v->nsubs]; v->nsubs < n; p++, v->nsubs++)
        *p = NULL;
    assert(v->nsubs == n);
    assert((size_t) wanted < v->nsubs);
}

References assert, ERR, MALLOC, vars::nsubs, REALLOC, REG_ESPACE, vars::sub10, vars::subs, and VS.

Referenced by parseqatom().

moveins()

static void moveins ( struct nfa *  , struct state *  , struct state *    )

static

Referenced by parsebranch(), parseqatom(), and repeat().

moveouts()

static void moveouts ( struct nfa *  , struct state *  , struct state *    )

static

Referenced by parseqatom(), and repeat().

newarc()

static void newarc ( struct nfa *  , int  , color  , struct state *  , struct state *    )

static

Referenced by cbracket(), makesearch(), nonword(), optimizebracket(), and processlacon().

newcolor()

static color newcolor ( struct colormap *  )

static

newcvec()

static struct cvec* newcvec ( int  , int    )

static

Referenced by pg_regcomp().

newfstate()

static struct state* newfstate ( struct nfa *  , int  flag  )

static

newhicolorcols()

static void newhicolorcols ( struct colormap *  )

static

newhicolorrow()

static int newhicolorrow ( struct colormap *  , int    )

static

newlacon()

static int newlacon ( struct vars *  v, struct state *  begin, struct state *  end, int  latype  )

static

Definition at line 2346 of file regcomp.c.

{
    int         n;
    struct subre *newlacons;
    struct subre *sub;
 
    if (v->nlacons == 0)
    {
        n = 1;                  /* skip 0th */
        newlacons = (struct subre *) MALLOC(2 * sizeof(struct subre));
    }
    else
    {
        n = v->nlacons;
        newlacons = (struct subre *) REALLOC(v->lacons,
                                             (n + 1) * sizeof(struct subre));
    }
    if (newlacons == NULL)
    {
        ERR(REG_ESPACE);
        return 0;
    }
    v->lacons = newlacons;
    v->nlacons = n + 1;
    sub = &v->lacons[n];
    sub->begin = begin;
    sub->end = end;
    sub->latype = latype;
    ZAPCNFA(sub->cnfa);
    return n;
}

References subre::begin, subre::cnfa, subre::end, ERR, vars::lacons, subre::latype, MALLOC, vars::nlacons, REALLOC, REG_ESPACE, and ZAPCNFA.

Referenced by processlacon().

newline()

static chr newline ( void  )

static

Referenced by pg_regcomp().

newnfa()

static struct nfa* newnfa ( struct vars *  , struct colormap *  , struct nfa *    )

static

Referenced by nfanode(), and pg_regcomp().

newstate()

static struct state* newstate ( struct nfa *  )

static

Referenced by cbracket(), charclasscomplement(), makesearch(), parse(), parsebranch(), parseqatom(), repeat(), and wordchrs().

newsub()

static color newsub ( struct colormap *  , color    )

static

next()

static int next ( struct vars *  )

static

Referenced by cleanst(), and freesubreandsiblings().

nfanode()

static long nfanode ( struct vars *  v, struct subre *  t, int  converttosearch, FILE *  f  )

static

Definition at line 2307 of file regcomp.c.

{
    struct nfa *nfa;
    long        ret = 0;
 
    assert(t->begin != NULL);
 
#ifdef REG_DEBUG
    if (f != NULL)
    {
        char        idbuf[50];
 
        fprintf(f, "\n\n\n========= TREE NODE %s ==========\n",
                stid(t, idbuf, sizeof(idbuf)));
    }
#endif
    nfa = newnfa(v, v->cm, v->nfa);
    NOERRZ();
    dupnfa(nfa, t->begin, t->end, nfa->init, nfa->final);
    if (!ISERR())
        specialcolors(nfa);
    if (!ISERR())
        ret = optimize(nfa, f);
    if (converttosearch && !ISERR())
        makesearch(v, nfa);
    if (!ISERR())
        compact(nfa, &t->cnfa);
 
    freenfa(nfa);
    return ret;
}

References assert, subre::begin, vars::cm, subre::cnfa, compact(), dupnfa(), subre::end, nfa::final, fprintf, freenfa(), nfa::init, ISERR, makesearch(), newnfa(), vars::nfa, NOERRZ, optimize(), specialcolors(), and nfa::v.

Referenced by nfatree(), and pg_regcomp().

nfatree()

static long nfatree ( struct vars *  v, struct subre *  t, FILE *  f  )

static

Definition at line 2287 of file regcomp.c.

{
    struct subre *t2;
 
    assert(t != NULL && t->begin != NULL);
 
    for (t2 = t->child; t2 != NULL; t2 = t2->sibling)
        (DISCARD) nfatree(v, t2, f);
 
    return nfanode(v, t, 0, f);
}

References assert, subre::begin, subre::child, DISCARD, nfanode(), and subre::sibling.

Referenced by pg_regcomp().

nonword()

static void nonword ( struct vars *  v, int  dir, struct state *  lp, struct state *  rp  )

static

Definition at line 1414 of file regcomp.c.

{
    int         anchor = (dir == AHEAD) ? '$' : '^';
 
    assert(dir == AHEAD || dir == BEHIND);
    newarc(v->nfa, anchor, 1, lp, rp);
    newarc(v->nfa, anchor, 0, lp, rp);
    colorcomplement(v->nfa, v->cm, dir, v->wordchrs, lp, rp);
    /* (no need for special attention to \n) */
}

References AHEAD, assert, BEHIND, vars::cm, colorcomplement(), newarc(), vars::nfa, and vars::wordchrs.

Referenced by parseqatom().

numst()

static int numst ( struct subre *  t, int  start  )

static

Definition at line 2220 of file regcomp.c.

{
    int         i;
    struct subre *t2;
 
    assert(t != NULL);
 
    i = start;
    t->id = i++;
    for (t2 = t->child; t2 != NULL; t2 = t2->sibling)
        i = numst(t2, i);
    return i;
}

References assert, subre::child, i, subre::id, and subre::sibling.

Referenced by pg_regcomp().

okcolors()

static void okcolors ( struct nfa *  , struct colormap *    )

static

Referenced by bracket(), charclasscomplement(), parseqatom(), pg_regcomp(), and wordchrs().

onechr()

static void onechr ( struct vars *  v, chr  c, struct state *  lp, struct state *  rp  )

static

Definition at line 1867 of file regcomp.c.

{
    if (!(v->cflags & REG_ICASE))
    {
        color       lastsubcolor = COLORLESS;
 
        subcoloronechr(v, c, lp, rp, &lastsubcolor);
        return;
    }
 
    /* rats, need general case anyway... */
    subcolorcvec(v, allcases(v, c), lp, rp);
}

References allcases(), vars::cflags, COLORLESS, REG_ICASE, subcolorcvec(), and subcoloronechr().

Referenced by brackpart(), and parseqatom().

optimize()

static long optimize ( struct nfa *  , FILE *    )

static

Referenced by nfanode(), and pg_regcomp().

optimizebracket()

static void optimizebracket ( struct vars *  v, struct state *  lp, struct state *  rp  )

static

Definition at line 1893 of file regcomp.c.

{
    struct colordesc *cd;
    struct colordesc *end = CDEND(v->cm);
    struct arc *a;
    bool        israinbow;
 
    /*
     * Scan lp's out-arcs and transiently mark the mentioned colors.  We
     * expect that all of lp's out-arcs are plain, non-RAINBOW arcs to rp.
     * (Note: there shouldn't be any pseudocolors yet, but check anyway.)
     */
    for (a = lp->outs; a != NULL; a = a->outchain)
    {
        assert(a->type == PLAIN);
        assert(a->co >= 0);     /* i.e. not RAINBOW */
        assert(a->to == rp);
        cd = &v->cm->cd[a->co];
        assert(!UNUSEDCOLOR(cd) && !(cd->flags & PSEUDO));
        cd->flags |= COLMARK;
    }
 
    /* Scan colors, clear transient marks, check for unmarked live colors */
    israinbow = true;
    for (cd = v->cm->cd; cd < end; cd++)
    {
        if (cd->flags & COLMARK)
            cd->flags &= ~COLMARK;
        else if (!UNUSEDCOLOR(cd) && !(cd->flags & PSEUDO))
            israinbow = false;
    }
 
    /* Can't do anything if not all colors have arcs */
    if (!israinbow)
        return;
 
    /* OK, drop existing arcs and replace with a rainbow */
    while ((a = lp->outs) != NULL)
        freearc(v->nfa, a);
    newarc(v->nfa, PLAIN, RAINBOW, lp, rp);
}

References a, assert, colormap::cd, CDEND, vars::cm, COLMARK, colordesc::flags, freearc(), newarc(), vars::nfa, state::outs, PLAIN, PSEUDO, RAINBOW, and UNUSEDCOLOR.

Referenced by bracket().

parse()

static struct subre * parse ( struct vars *  v, int  stopper, int  type, struct state *  init, struct state *  final  )

static

Definition at line 673 of file regcomp.c.

{
    struct subre *branches;     /* top level */
    struct subre *lastbranch;   /* latest branch */
 
    assert(stopper == ')' || stopper == EOS);
 
    branches = subre(v, '|', LONGER, init, final);
    NOERRN();
    lastbranch = NULL;
    do
    {                           /* a branch */
        struct subre *branch;
        struct state *left;     /* scaffolding for branch */
        struct state *right;
 
        left = newstate(v->nfa);
        right = newstate(v->nfa);
        NOERRN();
        EMPTYARC(init, left);
        EMPTYARC(right, final);
        NOERRN();
        branch = parsebranch(v, stopper, type, left, right, 0);
        NOERRN();
        if (lastbranch)
            lastbranch->sibling = branch;
        else
            branches->child = branch;
        branches->flags |= UP(branches->flags | branch->flags);
        lastbranch = branch;
    } while (EAT('|'));
    assert(SEE(stopper) || SEE(EOS));
 
    if (!SEE(stopper))
    {
        assert(stopper == ')' && SEE(EOS));
        ERR(REG_EPAREN);
    }
 
    /* optimize out simple cases */
    if (lastbranch == branches->child)
    {                           /* only one branch */
        assert(lastbranch->sibling == NULL);
        freesrnode(v, branches);
        branches = lastbranch;
    }
    else if (!MESSY(branches->flags))
    {                           /* no interesting innards */
        freesubreandsiblings(v, branches->child);
        branches->child = NULL;
        branches->op = '=';
    }
 
    return branches;
}

References assert, subre::child, EAT, EMPTYARC, EOS, ERR, subre::flags, freesrnode(), freesubreandsiblings(), init, LONGER, MESSY, newstate(), vars::nfa, NOERRN, subre::op, parsebranch(), REG_EPAREN, SEE, subre::sibling, subre(), generate_unaccent_rules::type, and UP.

Referenced by _outPlannerInfo(), add_foreign_final_paths(), add_foreign_grouping_paths(), add_foreign_ordered_paths(), add_paths_to_grouping_rel(), build_minmax_path(), can_partial_agg(), check_sql_fn_retval(), consider_groupingsets_paths(), convert_ANY_sublink_to_join(), convert_EXISTS_sublink_to_join(), create_degenerate_grouping_paths(), create_final_distinct_paths(), create_grouping_paths(), create_limit_plan(), create_partial_distinct_paths(), create_partial_grouping_paths(), delay_execution_planner(), distribute_row_identity_vars(), expand_single_inheritance_child(), flatten_simple_union_all(), get_number_of_groups(), get_useful_group_keys_orderings(), grouping_planner(), is_degenerate_grouping(), json_manifest_array_end(), json_manifest_array_start(), json_manifest_finalize_file(), json_manifest_finalize_wal_range(), json_manifest_object_end(), json_manifest_object_field_start(), json_manifest_object_start(), json_manifest_scalar(), json_parse_manifest(), limit_needed(), make_group_input_target(), make_partial_grouping_target(), make_sort_input_target(), make_window_input_target(), max_parallel_hazard(), parseqatom(), perform_pullup_replace_vars(), pg_regcomp(), pgss_planner(), plan_set_operations(), planner(), preprocess_groupclause(), preprocess_grouping_sets(), preprocess_limit(), preprocess_minmax_aggregates(), preprocess_rowmarks(), preprocess_targetlist(), pull_up_constant_function(), pull_up_simple_subquery(), pull_up_simple_values(), query_planner(), remove_useless_groupby_columns(), replace_empty_jointree(), resolve_unique_index_expr(), set_subquery_pathlist(), standard_planner(), standard_qp_callback(), subquery_planner(), transform_MERGE_to_join(), and verify_manifest_checksum().

parsebranch()

static struct subre * parsebranch ( struct vars *  v, int  stopper, int  type, struct state *  left, struct state *  right, int  partial  )

static

Definition at line 741 of file regcomp.c.

{
    struct state *lp;           /* left end of current construct */
    int         seencontent;    /* is there anything in this branch yet? */
    struct subre *t;
 
    lp = left;
    seencontent = 0;
    t = subre(v, '=', 0, left, right);  /* op '=' is tentative */
    NOERRN();
    while (!SEE('|') && !SEE(stopper) && !SEE(EOS))
    {
        if (seencontent)
        {                       /* implicit concat operator */
            lp = newstate(v->nfa);
            NOERRN();
            moveins(v->nfa, right, lp);
        }
        seencontent = 1;
 
        /* NB, recursion in parseqatom() may swallow rest of branch */
        t = parseqatom(v, stopper, type, lp, right, t);
        NOERRN();
    }
 
    if (!seencontent)
    {                           /* empty branch */
        if (!partial)
            NOTE(REG_UUNSPEC);
        assert(lp == left);
        EMPTYARC(left, right);
    }
 
    return t;
}

References assert, EMPTYARC, EOS, moveins(), newstate(), vars::nfa, NOERRN, NOTE, parseqatom(), REG_UUNSPEC, SEE, subre(), and generate_unaccent_rules::type.

Referenced by parse(), and parseqatom().

parseqatom()

static struct subre * parseqatom ( struct vars *  v, int  stopper, int  type, struct state *  lp, struct state *  rp, struct subre *  top  )

static

Definition at line 794 of file regcomp.c.

{
    struct state *s;            /* temporaries for new states */
    struct state *s2;
 
#define  ARCV(t, val)    newarc(v->nfa, t, val, lp, rp)
    int         m,
                n;
    struct subre *atom;         /* atom's subtree */
    struct subre *t;
    int         cap;            /* capturing parens? */
    int         latype;         /* lookaround constraint type */
    int         subno;          /* capturing-parens or backref number */
    int         atomtype;
    int         qprefer;        /* quantifier short/long preference */
    int         f;
    struct subre **atomp;       /* where the pointer to atom is */
 
    /* initial bookkeeping */
    atom = NULL;
    assert(lp->nouts == 0);     /* must string new code */
    assert(rp->nins == 0);      /* between lp and rp */
    subno = 0;                  /* just to shut lint up */
 
    /* an atom or constraint... */
    atomtype = v->nexttype;
    switch (atomtype)
    {
            /* first, constraints, which end by returning */
        case '^':
            ARCV('^', 1);
            if (v->cflags & REG_NLANCH)
                ARCV(BEHIND, v->nlcolor);
            NEXT();
            return top;
            break;
        case '$':
            ARCV('$', 1);
            if (v->cflags & REG_NLANCH)
                ARCV(AHEAD, v->nlcolor);
            NEXT();
            return top;
            break;
        case SBEGIN:
            ARCV('^', 1);       /* BOL */
            ARCV('^', 0);       /* or BOS */
            NEXT();
            return top;
            break;
        case SEND:
            ARCV('$', 1);       /* EOL */
            ARCV('$', 0);       /* or EOS */
            NEXT();
            return top;
            break;
        case '<':
            wordchrs(v);
            s = newstate(v->nfa);
            NOERRN();
            nonword(v, BEHIND, lp, s);
            word(v, AHEAD, s, rp);
            NEXT();
            return top;
            break;
        case '>':
            wordchrs(v);
            s = newstate(v->nfa);
            NOERRN();
            word(v, BEHIND, lp, s);
            nonword(v, AHEAD, s, rp);
            NEXT();
            return top;
            break;
        case WBDRY:
            wordchrs(v);
            s = newstate(v->nfa);
            NOERRN();
            nonword(v, BEHIND, lp, s);
            word(v, AHEAD, s, rp);
            s = newstate(v->nfa);
            NOERRN();
            word(v, BEHIND, lp, s);
            nonword(v, AHEAD, s, rp);
            NEXT();
            return top;
            break;
        case NWBDRY:
            wordchrs(v);
            s = newstate(v->nfa);
            NOERRN();
            word(v, BEHIND, lp, s);
            word(v, AHEAD, s, rp);
            s = newstate(v->nfa);
            NOERRN();
            nonword(v, BEHIND, lp, s);
            nonword(v, AHEAD, s, rp);
            NEXT();
            return top;
            break;
        case LACON:             /* lookaround constraint */
            latype = v->nextvalue;
            NEXT();
            s = newstate(v->nfa);
            s2 = newstate(v->nfa);
            NOERRN();
            t = parse(v, ')', LACON, s, s2);
            freesubre(v, t);    /* internal structure irrelevant */
            NOERRN();
            assert(SEE(')'));
            NEXT();
            processlacon(v, s, s2, latype, lp, rp);
            return top;
            break;
            /* then errors, to get them out of the way */
        case '*':
        case '+':
        case '?':
        case '{':
            ERR(REG_BADRPT);
            return top;
            break;
        default:
            ERR(REG_ASSERT);
            return top;
            break;
            /* then plain characters, and minor variants on that theme */
        case ')':               /* unbalanced paren */
            if ((v->cflags & REG_ADVANCED) != REG_EXTENDED)
            {
                ERR(REG_EPAREN);
                return top;
            }
            /* legal in EREs due to specification botch */
            NOTE(REG_UPBOTCH);
            /* fall through into case PLAIN */
            /* FALLTHROUGH */
        case PLAIN:
            onechr(v, v->nextvalue, lp, rp);
            okcolors(v->nfa, v->cm);
            NOERRN();
            NEXT();
            break;
        case '[':
            if (v->nextvalue == 1)
                bracket(v, lp, rp);
            else
                cbracket(v, lp, rp);
            assert(SEE(']') || ISERR());
            NEXT();
            break;
        case CCLASSS:
            charclass(v, (enum char_classes) v->nextvalue, lp, rp);
            okcolors(v->nfa, v->cm);
            NEXT();
            break;
        case CCLASSC:
            charclasscomplement(v, (enum char_classes) v->nextvalue, lp, rp);
            /* charclasscomplement() did okcolors() internally */
            NEXT();
            break;
        case '.':
            rainbow(v->nfa, v->cm, PLAIN,
                    (v->cflags & REG_NLSTOP) ? v->nlcolor : COLORLESS,
                    lp, rp);
            NEXT();
            break;
            /* and finally the ugly stuff */
        case '(':               /* value flags as capturing or non */
            cap = (type == LACON) ? 0 : v->nextvalue;
            if (cap)
            {
                v->nsubexp++;
                subno = v->nsubexp;
                if ((size_t) subno >= v->nsubs)
                    moresubs(v, subno);
            }
            else
                atomtype = PLAIN;   /* something that's not '(' */
            NEXT();
 
            /*
             * Make separate endpoint states to keep this sub-NFA distinct
             * from what surrounds it.  We need to be sure that when we
             * duplicate the sub-NFA for a backref, we get the right
             * states/arcs and no others.  In particular, letting a backref
             * duplicate the sub-NFA from lp to rp would be quite wrong,
             * because we may add quantification superstructure around this
             * atom below.  (Perhaps we could skip the extra states for
             * non-capturing parens, but it seems not worth the trouble.)
             */
            s = newstate(v->nfa);
            s2 = newstate(v->nfa);
            NOERRN();
            /* We may not need these arcs, but keep things connected for now */
            EMPTYARC(lp, s);
            EMPTYARC(s2, rp);
            NOERRN();
            atom = parse(v, ')', type, s, s2);
            assert(SEE(')') || ISERR());
            NEXT();
            NOERRN();
            if (cap)
            {
                if (atom->capno == 0)
                {
                    /* normal case: just mark the atom as capturing */
                    atom->flags |= CAP;
                    atom->capno = subno;
                }
                else
                {
                    /* generate no-op wrapper node to handle "((x))" */
                    t = subre(v, '(', atom->flags | CAP, s, s2);
                    NOERRN();
                    t->capno = subno;
                    t->child = atom;
                    atom = t;
                }
                assert(v->subs[subno] == NULL);
                v->subs[subno] = atom;
            }
            /* postpone everything else pending possible {0} */
            break;
        case BACKREF:           /* the Feature From The Black Lagoon */
            INSIST(type != LACON, REG_ESUBREG);
            subno = v->nextvalue;
            assert(subno > 0);
            INSIST(subno < v->nsubs, REG_ESUBREG);
            NOERRN();
            INSIST(v->subs[subno] != NULL, REG_ESUBREG);
            NOERRN();
            atom = subre(v, 'b', BACKR, lp, rp);
            NOERRN();
            atom->backno = subno;
            v->subs[subno]->flags |= BRUSE;
            EMPTYARC(lp, rp);   /* temporarily, so there's something */
            NEXT();
            break;
    }
 
    /* ...and an atom may be followed by a quantifier */
    switch (v->nexttype)
    {
        case '*':
            m = 0;
            n = DUPINF;
            qprefer = (v->nextvalue) ? LONGER : SHORTER;
            NEXT();
            break;
        case '+':
            m = 1;
            n = DUPINF;
            qprefer = (v->nextvalue) ? LONGER : SHORTER;
            NEXT();
            break;
        case '?':
            m = 0;
            n = 1;
            qprefer = (v->nextvalue) ? LONGER : SHORTER;
            NEXT();
            break;
        case '{':
            NEXT();
            m = scannum(v);
            if (EAT(','))
            {
                if (SEE(DIGIT))
                    n = scannum(v);
                else
                    n = DUPINF;
                if (m > n)
                {
                    ERR(REG_BADBR);
                    return top;
                }
                /* {m,n} exercises preference, even if it's {m,m} */
                qprefer = (v->nextvalue) ? LONGER : SHORTER;
            }
            else
            {
                n = m;
                /* {m} passes operand's preference through */
                qprefer = 0;
            }
            if (!SEE('}'))
            {                   /* catches errors too */
                ERR(REG_BADBR);
                return top;
            }
            NEXT();
            break;
        default:                /* no quantifier */
            m = n = 1;
            qprefer = 0;
            break;
    }
 
    /* annoying special case:  {0} or {0,0} cancels everything */
    if (m == 0 && n == 0)
    {
        /*
         * If we had capturing subexpression(s) within the atom, we don't want
         * to destroy them, because it's legal (if useless) to back-ref them
         * later.  Hence, just unlink the atom from lp/rp and then ignore it.
         */
        if (atom != NULL && (atom->flags & CAP))
        {
            delsub(v->nfa, lp, atom->begin);
            delsub(v->nfa, atom->end, rp);
        }
        else
        {
            /* Otherwise, we can clean up any subre infrastructure we made */
            if (atom != NULL)
                freesubre(v, atom);
            delsub(v->nfa, lp, rp);
        }
        EMPTYARC(lp, rp);
        return top;
    }
 
    /* if not a messy case, avoid hard part */
    assert(!MESSY(top->flags));
    f = top->flags | qprefer | ((atom != NULL) ? atom->flags : 0);
    if (atomtype != '(' && atomtype != BACKREF && !MESSY(UP(f)))
    {
        if (!(m == 1 && n == 1))
            repeat(v, lp, rp, m, n);
        if (atom != NULL)
            freesubre(v, atom);
        top->flags = f;
        return top;
    }
 
    /*
     * hard part:  something messy
     *
     * That is, capturing parens, back reference, short/long clash, or an atom
     * with substructure containing one of those.
     */
 
    /* now we'll need a subre for the contents even if they're boring */
    if (atom == NULL)
    {
        atom = subre(v, '=', 0, lp, rp);
        NOERRN();
    }
 
    /*
     * For what follows, we need the atom to have its own begin/end states
     * that are distinct from lp/rp, so that we can wrap iteration structure
     * around it.  The parenthesized-atom case above already made suitable
     * states (and we don't want to modify a capturing subre, since it's
     * already recorded in v->subs[]).  Otherwise, we need more states.
     */
    if (atom->begin == lp || atom->end == rp)
    {
        s = newstate(v->nfa);
        s2 = newstate(v->nfa);
        NOERRN();
        moveouts(v->nfa, lp, s);
        moveins(v->nfa, rp, s2);
        atom->begin = s;
        atom->end = s2;
    }
    else
    {
        /* The atom's OK, but we must temporarily disconnect it from lp/rp */
        /* (this removes the EMPTY arcs we made above) */
        delsub(v->nfa, lp, atom->begin);
        delsub(v->nfa, atom->end, rp);
    }
 
    /*----------
     * Prepare a general-purpose state skeleton.
     *
     * In the no-backrefs case, we want this:
     *
     * [lp] ---> [s] ---prefix---> ---atom---> ---rest---> [rp]
     *
     * where prefix is some repetitions of atom, and "rest" is the remainder
     * of the branch.  In the general case we need:
     *
     * [lp] ---> [s] ---iterator---> [s2] ---rest---> [rp]
     *
     * where the iterator wraps around the atom.
     *
     * We make the s state here for both cases; s2 is made below if needed
     *----------
     */
    s = newstate(v->nfa);       /* set up starting state */
    NOERRN();
    EMPTYARC(lp, s);
    NOERRN();
 
    /* break remaining subRE into x{...} and what follows */
    t = subre(v, '.', COMBINE(qprefer, atom->flags), lp, rp);
    NOERRN();
    t->child = atom;
    atomp = &t->child;
 
    /*
     * Here we should recurse to fill t->child->sibling ... but we must
     * postpone that to the end.  One reason is that t->child may be replaced
     * below, and we don't want to worry about its sibling link.
     */
 
    /*
     * Convert top node to a concatenation of the prefix (top->child, covering
     * whatever we parsed previously) and remaining (t).  Note that the prefix
     * could be empty, in which case this concatenation node is unnecessary.
     * To keep things simple, we operate in a general way for now, and get rid
     * of unnecessary subres below.
     */
    assert(top->op == '=' && top->child == NULL);
    top->child = subre(v, '=', top->flags, top->begin, lp);
    NOERRN();
    top->op = '.';
    top->child->sibling = t;
    /* top->flags will get updated later */
 
    /* if it's a backref, now is the time to replicate the subNFA */
    if (atomtype == BACKREF)
    {
        assert(atom->begin->nouts == 1);    /* just the EMPTY */
        delsub(v->nfa, atom->begin, atom->end);
        assert(v->subs[subno] != NULL);
 
        /*
         * And here's why the recursion got postponed: it must wait until the
         * skeleton is filled in, because it may hit a backref that wants to
         * copy the filled-in skeleton.
         */
        dupnfa(v->nfa, v->subs[subno]->begin, v->subs[subno]->end,
               atom->begin, atom->end);
        NOERRN();
 
        /* The backref node's NFA should not enforce any constraints */
        removeconstraints(v->nfa, atom->begin, atom->end);
        NOERRN();
    }
 
    /*
     * It's quantifier time.  If the atom is just a backref, we'll let it deal
     * with quantifiers internally.
     */
    if (atomtype == BACKREF)
    {
        /* special case:  backrefs have internal quantifiers */
        EMPTYARC(s, atom->begin);   /* empty prefix */
        /* just stuff everything into atom */
        repeat(v, atom->begin, atom->end, m, n);
        atom->min = (short) m;
        atom->max = (short) n;
        atom->flags |= COMBINE(qprefer, atom->flags);
        /* rest of branch can be strung starting from atom->end */
        s2 = atom->end;
    }
    else if (m == 1 && n == 1 &&
             (qprefer == 0 ||
              (atom->flags & (LONGER | SHORTER | MIXED)) == 0 ||
              qprefer == (atom->flags & (LONGER | SHORTER | MIXED))))
    {
        /* no/vacuous quantifier:  done */
        EMPTYARC(s, atom->begin);   /* empty prefix */
        /* rest of branch can be strung starting from atom->end */
        s2 = atom->end;
    }
    else if (!(atom->flags & (CAP | BACKR)))
    {
        /*
         * If there's no captures nor backrefs in the atom being repeated, we
         * don't really care where the submatches of the iteration are, so we
         * don't need an iteration node.  Make a plain DFA node instead.
         */
        EMPTYARC(s, atom->begin);   /* empty prefix */
        repeat(v, atom->begin, atom->end, m, n);
        f = COMBINE(qprefer, atom->flags);
        t = subre(v, '=', f, atom->begin, atom->end);
        NOERRN();
        freesubre(v, atom);
        *atomp = t;
        /* rest of branch can be strung starting from t->end */
        s2 = t->end;
    }
    else if (m > 0 && !(atom->flags & BACKR))
    {
        /*
         * If there's no backrefs involved, we can turn x{m,n} into
         * x{m-1,n-1}x, with capturing parens in only the second x.  This is
         * valid because we only care about capturing matches from the final
         * iteration of the quantifier.  It's a win because we can implement
         * the backref-free left side as a plain DFA node, since we don't
         * really care where its submatches are.
         */
        dupnfa(v->nfa, atom->begin, atom->end, s, atom->begin);
        assert(m >= 1 && m != DUPINF && n >= 1);
        repeat(v, s, atom->begin, m - 1, (n == DUPINF) ? n : n - 1);
        f = COMBINE(qprefer, atom->flags);
        t = subre(v, '.', f, s, atom->end); /* prefix and atom */
        NOERRN();
        t->child = subre(v, '=', PREF(f), s, atom->begin);
        NOERRN();
        t->child->sibling = atom;
        *atomp = t;
        /* rest of branch can be strung starting from atom->end */
        s2 = atom->end;
    }
    else
    {
        /* general case: need an iteration node */
        s2 = newstate(v->nfa);
        NOERRN();
        moveouts(v->nfa, atom->end, s2);
        NOERRN();
        dupnfa(v->nfa, atom->begin, atom->end, s, s2);
        repeat(v, s, s2, m, n);
        f = COMBINE(qprefer, atom->flags);
        t = subre(v, '*', f, s, s2);
        NOERRN();
        t->min = (short) m;
        t->max = (short) n;
        t->child = atom;
        *atomp = t;
        /* rest of branch is to be strung from iteration's end state */
    }
 
    /* and finally, look after that postponed recursion */
    t = top->child->sibling;
    if (!(SEE('|') || SEE(stopper) || SEE(EOS)))
    {
        /* parse all the rest of the branch, and insert in t->child->sibling */
        t->child->sibling = parsebranch(v, stopper, type, s2, rp, 1);
        NOERRN();
        assert(SEE('|') || SEE(stopper) || SEE(EOS));
 
        /* here's the promised update of the flags */
        t->flags |= COMBINE(t->flags, t->child->sibling->flags);
        top->flags |= COMBINE(top->flags, t->flags);
 
        /* neither t nor top could be directly marked for capture as yet */
        assert(t->capno == 0);
        assert(top->capno == 0);
 
        /*
         * At this point both top and t are concatenation (op == '.') subres,
         * and we have top->child = prefix of branch, top->child->sibling = t,
         * t->child = messy atom (with quantification superstructure if
         * needed), t->child->sibling = rest of branch.
         *
         * If the messy atom was the first thing in the branch, then
         * top->child is vacuous and we can get rid of one level of
         * concatenation.
         */
        assert(top->child->op == '=');
        if (top->child->begin == top->child->end)
        {
            assert(!MESSY(top->child->flags));
            freesubre(v, top->child);
            top->child = t->child;
            freesrnode(v, t);
        }
 
        /*
         * Otherwise, it's possible that t->child is not messy in itself, but
         * we considered it messy because its greediness conflicts with what
         * preceded it.  Then it could be that the combination of t->child and
         * the rest of the branch is also not messy, in which case we can get
         * rid of the child concatenation by merging t->child and the rest of
         * the branch into one plain DFA node.
         */
        else if (t->child->op == '=' &&
                 t->child->sibling->op == '=' &&
                 !MESSY(UP(t->child->flags | t->child->sibling->flags)))
        {
            t->op = '=';
            t->flags = COMBINE(t->child->flags, t->child->sibling->flags);
            freesubreandsiblings(v, t->child);
            t->child = NULL;
        }
    }
    else
    {
        /*
         * There's nothing left in the branch, so we don't need the second
         * concatenation node 't'.  Just link s2 straight to rp.
         */
        EMPTYARC(s2, rp);
        top->child->sibling = t->child;
        top->flags |= COMBINE(top->flags, top->child->sibling->flags);
        freesrnode(v, t);
 
        /*
         * Again, it could be that top->child is vacuous (if the messy atom
         * was in fact the only thing in the branch).  In that case we need no
         * concatenation at all; just replace top with top->child->sibling.
         */
        assert(top->child->op == '=');
        if (top->child->begin == top->child->end)
        {
            assert(!MESSY(top->child->flags));
            t = top->child->sibling;
            top->child->sibling = NULL;
            freesubre(v, top);
            top = t;
        }
    }
 
    return top;
}

References AHEAD, ARCV, assert, subre::backno, BACKR, BACKREF, subre::begin, BEHIND, bracket(), BRUSE, CAP, subre::capno, cbracket(), CCLASSC, CCLASSS, vars::cflags, charclass(), charclasscomplement(), subre::child, vars::cm, COLORLESS, COMBINE, delsub(), DIGIT, DUPINF, dupnfa(), EAT, EMPTYARC, subre::end, EOS, ERR, subre::flags, freesrnode(), freesubre(), freesubreandsiblings(), if(), INSIST, ISERR, LACON, subre::latype, LONGER, subre::max, MESSY, subre::min, MIXED, moresubs(), moveins(), moveouts(), newstate(), NEXT, vars::nexttype, vars::nextvalue, vars::nfa, state::nins, vars::nlcolor, NOERRN, nonword(), NOTE, state::nouts, vars::nsubexp, vars::nsubs, NWBDRY, okcolors(), onechr(), subre::op, parse(), parsebranch(), PLAIN, PREF, processlacon(), rainbow(), REG_ADVANCED, REG_ASSERT, REG_BADBR, REG_BADRPT, REG_EPAREN, REG_ESUBREG, REG_EXTENDED, REG_NLANCH, REG_NLSTOP, REG_UPBOTCH, removeconstraints(), repeat(), s2, SBEGIN, scannum(), SEE, SEND, SHORTER, subre::sibling, subre(), vars::subs, generate_unaccent_rules::type, UP, WBDRY, word(), and wordchrs().

Referenced by parsebranch().

pg_regcomp()

int pg_regcomp	(	regex_t *	re,
		const chr *	string,
		size_t	len,
		int	flags,
		Oid	collation
	)

Definition at line 328 of file regcomp.c.

{
    struct vars var;
    struct vars *v = &var;
    struct guts *g;
    int         i;
    size_t      j;
 
#ifdef REG_DEBUG
    FILE       *debug = (flags & REG_PROGRESS) ? stdout : (FILE *) NULL;
#else
    FILE       *debug = (FILE *) NULL;
#endif
 
#define  CNOERR()    { if (ISERR()) return freev(v, v->err); }
 
    /* sanity checks */
 
    if (re == NULL || string == NULL)
        return REG_INVARG;
    if ((flags & REG_QUOTE) &&
        (flags & (REG_ADVANCED | REG_EXPANDED | REG_NEWLINE)))
        return REG_INVARG;
    if (!(flags & REG_EXTENDED) && (flags & REG_ADVF))
        return REG_INVARG;
 
    /* Initialize locale-dependent support */
    pg_set_regex_collation(collation);
 
    /* initial setup (after which freev() is callable) */
    v->re = re;
    v->now = string;
    v->stop = v->now + len;
    v->err = 0;
    v->cflags = flags;
    v->nsubexp = 0;
    v->subs = v->sub10;
    v->nsubs = 10;
    for (j = 0; j < v->nsubs; j++)
        v->subs[j] = NULL;
    v->nfa = NULL;
    v->cm = NULL;
    v->nlcolor = COLORLESS;
    v->wordchrs = NULL;
    v->tree = NULL;
    v->treechain = NULL;
    v->treefree = NULL;
    v->cv = NULL;
    v->cv2 = NULL;
    v->lacons = NULL;
    v->nlacons = 0;
    v->spaceused = 0;
    re->re_magic = REMAGIC;
    re->re_info = 0;            /* bits get set during parse */
    re->re_csize = sizeof(chr);
    re->re_collation = collation;
    re->re_guts = NULL;
    re->re_fns = VS(&functions);
 
    /* more complex setup, malloced things */
    re->re_guts = VS(MALLOC(sizeof(struct guts)));
    if (re->re_guts == NULL)
        return freev(v, REG_ESPACE);
    g = (struct guts *) re->re_guts;
    g->tree = NULL;
    initcm(v, &g->cmap);
    v->cm = &g->cmap;
    g->lacons = NULL;
    g->nlacons = 0;
    ZAPCNFA(g->search);
    v->nfa = newnfa(v, v->cm, (struct nfa *) NULL);
    CNOERR();
    /* set up a reasonably-sized transient cvec for getcvec usage */
    v->cv = newcvec(100, 20);
    if (v->cv == NULL)
        return freev(v, REG_ESPACE);
 
    /* parsing */
    lexstart(v);                /* also handles prefixes */
    if ((v->cflags & REG_NLSTOP) || (v->cflags & REG_NLANCH))
    {
        /* assign newline a unique color */
        v->nlcolor = subcolor(v->cm, newline());
        okcolors(v->nfa, v->cm);
    }
    CNOERR();
    v->tree = parse(v, EOS, PLAIN, v->nfa->init, v->nfa->final);
    assert(SEE(EOS));           /* even if error; ISERR() => SEE(EOS) */
    CNOERR();
    assert(v->tree != NULL);
 
    /* finish setup of nfa and its subre tree */
    specialcolors(v->nfa);
    CNOERR();
#ifdef REG_DEBUG
    if (debug != NULL)
    {
        fprintf(debug, "\n\n\n========= RAW ==========\n");
        dumpnfa(v->nfa, debug);
        dumpst(v->tree, debug, 1);
    }
#endif
    if (v->cflags & REG_NOSUB)
        removecaptures(v, v->tree);
    v->ntree = numst(v->tree, 1);
    markst(v->tree);
    cleanst(v);
#ifdef REG_DEBUG
    if (debug != NULL)
    {
        fprintf(debug, "\n\n\n========= TREE FIXED ==========\n");
        dumpst(v->tree, debug, 1);
    }
#endif
 
    /* build compacted NFAs for tree and lacons */
    re->re_info |= nfatree(v, v->tree, debug);
    CNOERR();
    assert(v->nlacons == 0 || v->lacons != NULL);
    for (i = 1; i < v->nlacons; i++)
    {
        struct subre *lasub = &v->lacons[i];
 
#ifdef REG_DEBUG
        if (debug != NULL)
            fprintf(debug, "\n\n\n========= LA%d ==========\n", i);
#endif
 
        /* Prepend .* to pattern if it's a lookbehind LACON */
        nfanode(v, lasub, !LATYPE_IS_AHEAD(lasub->latype), debug);
    }
    CNOERR();
    if (v->tree->flags & SHORTER)
        NOTE(REG_USHORTEST);
 
    /* build compacted NFAs for tree, lacons, fast search */
#ifdef REG_DEBUG
    if (debug != NULL)
        fprintf(debug, "\n\n\n========= SEARCH ==========\n");
#endif
    /* can sacrifice main NFA now, so use it as work area */
    (DISCARD) optimize(v->nfa, debug);
    CNOERR();
    makesearch(v, v->nfa);
    CNOERR();
    compact(v->nfa, &g->search);
    CNOERR();
 
    /* looks okay, package it up */
    re->re_nsub = v->nsubexp;
    v->re = NULL;               /* freev no longer frees re */
    g->magic = GUTSMAGIC;
    g->cflags = v->cflags;
    g->info = re->re_info;
    g->nsub = re->re_nsub;
    g->tree = v->tree;
    v->tree = NULL;
    g->ntree = v->ntree;
    g->compare = (v->cflags & REG_ICASE) ? casecmp : cmp;
    g->lacons = v->lacons;
    v->lacons = NULL;
    g->nlacons = v->nlacons;
 
#ifdef REG_DEBUG
    if (flags & REG_DUMP)
    {
        dump(re, stdout);
        fflush(stdout);
    }
#endif
 
    assert(v->err == 0);
    return freev(v, 0);
}

References assert, casecmp(), vars::cflags, guts::cflags, cleanst(), vars::cm, guts::cmap, cmp(), CNOERR, COLORLESS, compact(), vars::cv, vars::cv2, debug, DISCARD, dumpnfa(), EOS, vars::err, fflush(), nfa::final, subre::flags, fprintf, freev(), functions, GUTSMAGIC, i, guts::info, nfa::init, initcm(), j, vars::lacons, guts::lacons, subre::latype, LATYPE_IS_AHEAD, len, lexstart(), guts::magic, makesearch(), MALLOC, markst(), newcvec(), newline(), newnfa(), vars::nfa, nfanode(), nfatree(), vars::nlacons, guts::nlacons, vars::nlcolor, NOTE, vars::now, guts::nsub, vars::nsubexp, vars::nsubs, vars::ntree, guts::ntree, numst(), okcolors(), optimize(), parse(), pg_set_regex_collation(), PLAIN, vars::re, regex_t::re_collation, regex_t::re_csize, regex_t::re_fns, regex_t::re_guts, regex_t::re_info, regex_t::re_magic, regex_t::re_nsub, REG_ADVANCED, REG_ADVF, REG_DUMP, REG_ESPACE, REG_EXPANDED, REG_EXTENDED, REG_ICASE, REG_INVARG, REG_NEWLINE, REG_NLANCH, REG_NLSTOP, REG_NOSUB, REG_PROGRESS, REG_QUOTE, REG_USHORTEST, REMAGIC, removecaptures(), guts::search, SEE, SHORTER, vars::spaceused, specialcolors(), generate_unaccent_rules::stdout, vars::stop, vars::sub10, subcolor(), vars::subs, vars::tree, guts::tree, vars::treechain, vars::treefree, VS, vars::wordchrs, and ZAPCNFA.

Referenced by NIAddAffix(), parse_ident_line(), RE_compile(), RE_compile_and_cache(), and test_re_compile().

pg_wc_isalnum()

static int pg_wc_isalnum ( pg_wchar  c )

static

pg_wc_isalpha()

static int pg_wc_isalpha ( pg_wchar  c )

static

pg_wc_isdigit()

static int pg_wc_isdigit ( pg_wchar  c )

static

pg_wc_isgraph()

static int pg_wc_isgraph ( pg_wchar  c )

static

pg_wc_islower()

static int pg_wc_islower ( pg_wchar  c )

static

pg_wc_isprint()

static int pg_wc_isprint ( pg_wchar  c )

static

pg_wc_ispunct()

static int pg_wc_ispunct ( pg_wchar  c )

static

pg_wc_isspace()

static int pg_wc_isspace ( pg_wchar  c )

static

pg_wc_isupper()

static int pg_wc_isupper ( pg_wchar  c )

static

pg_wc_isword()

static int pg_wc_isword ( pg_wchar  c )

static

pg_wc_tolower()

static pg_wchar pg_wc_tolower ( pg_wchar  c )

static

pg_wc_toupper()

static pg_wchar pg_wc_toupper ( pg_wchar  c )

static

prefixes()

static void prefixes ( struct vars *  )

static

processlacon()

static void processlacon ( struct vars *  v, struct state *  begin, struct state *  end, int  latype, struct state *  lp, struct state *  rp  )

static

Definition at line 1985 of file regcomp.c.

{
    struct state *s1;
    int         n;
 
    /*
     * Check for lookaround RE consisting of a single plain color arc (or set
     * of arcs); this would typically be a simple chr or a bracket expression.
     */
    s1 = single_color_transition(begin, end);
    switch (latype)
    {
        case LATYPE_AHEAD_POS:
            /* If lookahead RE is just colorset C, convert to AHEAD(C) */
            if (s1 != NULL)
            {
                cloneouts(v->nfa, s1, lp, rp, AHEAD);
                return;
            }
            break;
        case LATYPE_AHEAD_NEG:
            /* If lookahead RE is just colorset C, convert to AHEAD(^C)|$ */
            if (s1 != NULL)
            {
                colorcomplement(v->nfa, v->cm, AHEAD, s1, lp, rp);
                newarc(v->nfa, '$', 1, lp, rp);
                newarc(v->nfa, '$', 0, lp, rp);
                return;
            }
            break;
        case LATYPE_BEHIND_POS:
            /* If lookbehind RE is just colorset C, convert to BEHIND(C) */
            if (s1 != NULL)
            {
                cloneouts(v->nfa, s1, lp, rp, BEHIND);
                return;
            }
            break;
        case LATYPE_BEHIND_NEG:
            /* If lookbehind RE is just colorset C, convert to BEHIND(^C)|^ */
            if (s1 != NULL)
            {
                colorcomplement(v->nfa, v->cm, BEHIND, s1, lp, rp);
                newarc(v->nfa, '^', 1, lp, rp);
                newarc(v->nfa, '^', 0, lp, rp);
                return;
            }
            break;
        default:
            assert(NOTREACHED);
    }
 
    /* General case: we need a LACON subre and arc */
    n = newlacon(v, begin, end, latype);
    newarc(v->nfa, LACON, n, lp, rp);
}

References AHEAD, assert, BEHIND, cloneouts(), vars::cm, colorcomplement(), LACON, LATYPE_AHEAD_NEG, LATYPE_AHEAD_POS, LATYPE_BEHIND_NEG, LATYPE_BEHIND_POS, newarc(), newlacon(), vars::nfa, NOTREACHED, s1, and single_color_transition().

Referenced by parseqatom().

pseudocolor()

static color pseudocolor ( struct colormap *  )

static

pull()

static int pull ( struct nfa *  , struct arc *  , struct state **    )

static

pullback()

static void pullback ( struct nfa *  , FILE *    )

static

push()

static int push ( struct nfa *  , struct arc *  , struct state **    )

static

pushfwd()

static void pushfwd ( struct nfa *  , FILE *    )

static

rainbow()

static void rainbow ( struct nfa *  , struct colormap *  , int  , color  , struct state *  , struct state *    )

static

Referenced by makesearch(), and parseqatom().

range()

static struct cvec* range ( struct vars *  , chr  , chr  , int    )

static

Referenced by brackpart().

rcancelrequested()

static int rcancelrequested ( void  )

static

Definition at line 2438 of file regcomp.c.

{
    return InterruptPending && (QueryCancelPending || ProcDiePending);
}

References InterruptPending, ProcDiePending, and QueryCancelPending.

removecaptures()

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

static

Definition at line 2174 of file regcomp.c.

{
    struct subre *t2;
 
    assert(t != NULL);
 
    /*
     * If this isn't itself a backref target, clear capno and tentatively
     * clear CAP flag.
     */
    if (!(t->flags & BRUSE))
    {
        t->capno = 0;
        t->flags &= ~CAP;
    }
 
    /* Now recurse to children */
    for (t2 = t->child; t2 != NULL; t2 = t2->sibling)
    {
        removecaptures(v, t2);
        /* Propagate child CAP flag back up, if it's still set */
        if (t2->flags & CAP)
            t->flags |= CAP;
    }
 
    /*
     * If t now contains neither captures nor backrefs, there's no longer any
     * need to care where its sub-match boundaries are, so we can reduce it to
     * a simple DFA node.  (Note in particular that MIXED child greediness is
     * not a hindrance here, so we don't use the MESSY() macro.)
     */
    if ((t->flags & (CAP | BACKR)) == 0)
    {
        if (t->child)
            freesubreandsiblings(v, t->child);
        t->child = NULL;
        t->op = '=';
        t->flags &= ~MIXED;
    }
}

References assert, BACKR, BRUSE, CAP, subre::capno, subre::child, subre::flags, freesubreandsiblings(), MIXED, subre::op, and subre::sibling.

Referenced by pg_regcomp().

removeconstraints()

static void removeconstraints ( struct nfa *  , struct state *  , struct state *    )

static

Referenced by parseqatom().

removetraverse()

static void removetraverse ( struct nfa *  , struct state *    )

static

repeat()

static void repeat ( struct vars *  v, struct state *  lp, struct state *  rp, int  m, int  n  )

static

Definition at line 1542 of file regcomp.c.

{
#define  SOME    2
#define  INF     3
#define  PAIR(x, y)  ((x)*4 + (y))
#define  REDUCE(x)   ( ((x) == DUPINF) ? INF : (((x) > 1) ? SOME : (x)) )
    const int   rm = REDUCE(m);
    const int   rn = REDUCE(n);
    struct state *s;
    struct state *s2;
 
    switch (PAIR(rm, rn))
    {
        case PAIR(0, 0):        /* empty string */
            delsub(v->nfa, lp, rp);
            EMPTYARC(lp, rp);
            break;
        case PAIR(0, 1):        /* do as x| */
            EMPTYARC(lp, rp);
            break;
        case PAIR(0, SOME):     /* do as x{1,n}| */
            repeat(v, lp, rp, 1, n);
            NOERR();
            EMPTYARC(lp, rp);
            break;
        case PAIR(0, INF):      /* loop x around */
            s = newstate(v->nfa);
            NOERR();
            moveouts(v->nfa, lp, s);
            moveins(v->nfa, rp, s);
            EMPTYARC(lp, s);
            EMPTYARC(s, rp);
            break;
        case PAIR(1, 1):        /* no action required */
            break;
        case PAIR(1, SOME):     /* do as x{0,n-1}x = (x{1,n-1}|)x */
            s = newstate(v->nfa);
            NOERR();
            moveouts(v->nfa, lp, s);
            dupnfa(v->nfa, s, rp, lp, s);
            NOERR();
            repeat(v, lp, s, 1, n - 1);
            NOERR();
            EMPTYARC(lp, s);
            break;
        case PAIR(1, INF):      /* add loopback arc */
            s = newstate(v->nfa);
            s2 = newstate(v->nfa);
            NOERR();
            moveouts(v->nfa, lp, s);
            moveins(v->nfa, rp, s2);
            EMPTYARC(lp, s);
            EMPTYARC(s2, rp);
            EMPTYARC(s2, s);
            break;
        case PAIR(SOME, SOME):  /* do as x{m-1,n-1}x */
            s = newstate(v->nfa);
            NOERR();
            moveouts(v->nfa, lp, s);
            dupnfa(v->nfa, s, rp, lp, s);
            NOERR();
            repeat(v, lp, s, m - 1, n - 1);
            break;
        case PAIR(SOME, INF):   /* do as x{m-1,}x */
            s = newstate(v->nfa);
            NOERR();
            moveouts(v->nfa, lp, s);
            dupnfa(v->nfa, s, rp, lp, s);
            NOERR();
            repeat(v, lp, s, m - 1, n);
            break;
        default:
            ERR(REG_ASSERT);
            break;
    }
}

References delsub(), dupnfa(), EMPTYARC, ERR, INF, moveins(), moveouts(), newstate(), vars::nfa, NOERR, PAIR, REDUCE, REG_ASSERT, s2, and SOME.

Referenced by parseqatom().

rfree()

static void rfree ( regex_t *  re )

static

Definition at line 2402 of file regcomp.c.

{
    struct guts *g;
 
    if (re == NULL || re->re_magic != REMAGIC)
        return;
 
    re->re_magic = 0;           /* invalidate RE */
    g = (struct guts *) re->re_guts;
    re->re_guts = NULL;
    re->re_fns = NULL;
    if (g != NULL)
    {
        g->magic = 0;
        freecm(&g->cmap);
        if (g->tree != NULL)
            freesubre((struct vars *) NULL, g->tree);
        if (g->lacons != NULL)
            freelacons(g->lacons, g->nlacons);
        if (!NULLCNFA(g->search))
            freecnfa(&g->search);
        FREE(g);
    }
}

References guts::cmap, FREE, freecm(), freecnfa(), freelacons(), freesubre(), if(), guts::lacons, guts::magic, guts::nlacons, NULLCNFA, regex_t::re_fns, regex_t::re_guts, regex_t::re_magic, REMAGIC, guts::search, and guts::tree.

Referenced by freev().

rstacktoodeep()

static int rstacktoodeep ( void  )

static

Definition at line 2454 of file regcomp.c.

{
    return stack_is_too_deep();
}

References stack_is_too_deep().

scannum()

static int scannum ( struct vars *  v )

static

Definition at line 1511 of file regcomp.c.

{
    int         n = 0;
 
    while (SEE(DIGIT) && n < DUPMAX)
    {
        n = n * 10 + v->nextvalue;
        NEXT();
    }
    if (SEE(DIGIT) || n > DUPMAX)
    {
        ERR(REG_BADBR);
        return 0;
    }
    return n;
}

References DIGIT, DUPMAX, ERR, NEXT, vars::nextvalue, REG_BADBR, and SEE.

Referenced by parseqatom().

scanplain()

static const chr * scanplain ( struct vars *  v )

static

Definition at line 1842 of file regcomp.c.

{
    const chr  *endp;
 
    assert(SEE(COLLEL) || SEE(ECLASS) || SEE(CCLASS));
    NEXT();
 
    endp = v->now;
    while (SEE(PLAIN))
    {
        endp = v->now;
        NEXT();
    }
 
    assert(SEE(END) || ISERR());
    NEXT();
 
    return endp;
}

References assert, CCLASS, COLLEL, ECLASS, END, ISERR, NEXT, vars::now, PLAIN, and SEE.

Referenced by brackpart().

single_color_transition()

static struct state* single_color_transition ( struct state *  , struct state *    )

static

Referenced by processlacon().

skip()

static void skip ( struct vars *  )

static

sortins()

static void sortins ( struct nfa *  , struct state *    )

static

sortins_cmp()

static int sortins_cmp ( const void *  , const void *    )

static

sortouts()

static void sortouts ( struct nfa *  , struct state *    )

static

sortouts_cmp()

static int sortouts_cmp ( const void *  , const void *    )

static

specialcolors()

static void specialcolors ( struct nfa *  )

static

Referenced by nfanode(), and pg_regcomp().

subcolor()

static color subcolor ( struct colormap *  , chr    )

static

Referenced by pg_regcomp().

subcolorcvec()

static void subcolorcvec ( struct vars *  , struct cvec *  , struct state *  , struct state *    )

static

Referenced by brackpart(), charclass(), charclasscomplement(), onechr(), and wordchrs().

subcolorhi()

static color subcolorhi ( struct colormap *  , color *    )

static

subcoloronechr()

static void subcoloronechr ( struct vars *  , chr  , struct state *  , struct state *  , color *    )

static

Referenced by onechr().

subcoloronerange()

static void subcoloronerange ( struct vars *  , chr  , chr  , struct state *  , struct state *  , color *    )

static

subcoloronerow()

static void subcoloronerow ( struct vars *  , int  , struct state *  , struct state *  , color *    )

static

subre()

static struct subre * subre ( struct vars *  v, int  op, int  flags, struct state *  begin, struct state *  end  )

static

Definition at line 2051 of file regcomp.c.

{
    struct subre *ret = v->treefree;
 
    /*
     * Checking for stack overflow here is sufficient to protect parse() and
     * its recursive subroutines.
     */
    if (STACK_TOO_DEEP(v->re))
    {
        ERR(REG_ETOOBIG);
        return NULL;
    }
 
    if (ret != NULL)
        v->treefree = ret->child;
    else
    {
        ret = (struct subre *) MALLOC(sizeof(struct subre));
        if (ret == NULL)
        {
            ERR(REG_ESPACE);
            return NULL;
        }
        ret->chain = v->treechain;
        v->treechain = ret;
    }
 
    assert(strchr("=b|.*(", op) != NULL);
 
    ret->op = op;
    ret->flags = flags;
    ret->latype = (char) -1;
    ret->id = 0;                /* will be assigned later */
    ret->capno = 0;
    ret->backno = 0;
    ret->min = ret->max = 1;
    ret->child = NULL;
    ret->sibling = NULL;
    ret->begin = begin;
    ret->end = end;
    ZAPCNFA(ret->cnfa);
 
    return ret;
}

References assert, subre::backno, subre::begin, subre::capno, subre::chain, subre::child, subre::cnfa, subre::end, ERR, subre::flags, subre::id, subre::latype, MALLOC, subre::max, subre::min, subre::op, vars::re, REG_ESPACE, REG_ETOOBIG, subre::sibling, STACK_TOO_DEEP, vars::treechain, vars::treefree, and ZAPCNFA.

Referenced by parse(), parsebranch(), and parseqatom().

uncolorchain()

static void uncolorchain ( struct colormap *  , struct arc *    )

static

word()

static void word ( struct vars *  v, int  dir, struct state *  lp, struct state *  rp  )

static

Definition at line 1432 of file regcomp.c.

{
    assert(dir == AHEAD || dir == BEHIND);
    cloneouts(v->nfa, v->wordchrs, lp, rp, dir);
    /* (no need for special attention to \n) */
}

References AHEAD, assert, BEHIND, cloneouts(), vars::nfa, and vars::wordchrs.

Referenced by _metaphone(), addNorm(), AddStem(), addToResult(), byword(), CheckAffix(), CheckCompoundAffixes(), ciprefix(), cmpspell(), compareWORD(), dxsyn_lexize(), FindAffixes(), FindWord(), hlfinditem(), itsabbr(), Lookahead(), NIAddSpell(), NINormalizeWord(), NormalizeSubWord(), parseqatom(), pg_leftmost_one_pos32(), pg_leftmost_one_pos64(), pg_popcount32(), pg_popcount32_slow(), pg_popcount64(), pg_popcount64_slow(), pg_rightmost_one_pos32(), pg_rightmost_one_pos64(), pg_rotate_left32(), pg_rotate_right32(), plpgsql_parse_word(), SplitToVariants(), and unicode_to_utf8word().

wordchrs()

static void wordchrs ( struct vars *  v )

static

Definition at line 1949 of file regcomp.c.

{
    struct state *cstate;
    struct cvec *cv;
 
    if (v->wordchrs != NULL)
        return;                 /* done already */
 
    /* make dummy state to hang the cache arcs on */
    cstate = newstate(v->nfa);
    NOERR();
 
    /* obtain possibly-cached cvec for \w characters */
    NOTE(REG_ULOCALE);
    cv = cclasscvec(v, CC_WORD, (v->cflags & REG_ICASE));
    NOERR();
 
    /* build the arcs; this may cause color splitting */
    subcolorcvec(v, cv, cstate, cstate);
    NOERR();
 
    /* close new open subcolors to ensure the cache entry is self-contained */
    okcolors(v->nfa, v->cm);
    NOERR();
 
    /* success! save the cache pointer */
    v->wordchrs = cstate;
}

References CC_WORD, cclasscvec(), vars::cflags, vars::cm, newstate(), vars::nfa, NOERR, NOTE, okcolors(), REG_ICASE, REG_ULOCALE, subcolorcvec(), and vars::wordchrs.

Referenced by parseqatom().

Variable Documentation

functions

const struct fns functions

static

Initial value:

= {
    rfree,                      
    rcancelrequested,           
    rstacktoodeep               
}

Definition at line 233 of file regcomp.c.

Referenced by _copyFunctionScan(), _copyRangeFunction(), _copyRangeTblEntry(), _equalRangeFunction(), _equalRangeTblEntry(), _outFunctionScan(), _outRangeFunction(), _outRangeTblEntry(), _readFunctionScan(), _readRangeTblEntry(), btadjustmembers(), create_functionscan_plan(), ExplainNode(), ginadjustmembers(), gistadjustmembers(), hashadjustmembers(), make_functionscan(), pg_regcomp(), and spgadjustmembers().