regex.h File Reference

#include "mb/pg_wchar.h"

Include dependency graph for regex.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	regex_t
struct	regmatch_t
struct	rm_detail_t

Macros
#define	_REGEX_H_   /* never again */
#define	REG_UBACKREF   000001 /* has back-reference (\n) */
#define	REG_ULOOKAROUND   000002 /* has lookahead/lookbehind constraint */
#define	REG_UBOUNDS   000004 /* has bounded quantifier ({m,n}) */
#define	REG_UBRACES   000010 /* has { that doesn't begin a quantifier */
#define	REG_UBSALNUM   000020 /* has backslash-alphanumeric in non-ARE */
#define	REG_UPBOTCH
#define	REG_UBBS   000100 /* has backslash within bracket expr */
#define	REG_UNONPOSIX   000200 /* has any construct that extends POSIX */
#define	REG_UUNSPEC
#define	REG_UUNPORT   001000 /* has numeric character code dependency */
#define	REG_ULOCALE   002000 /* has locale dependency */
#define	REG_UEMPTYMATCH   004000 /* can match a zero-length string */
#define	REG_UIMPOSSIBLE   010000 /* provably cannot match anything */
#define	REG_USHORTEST   020000 /* has non-greedy quantifier */
#define	REG_BASIC   000000 /* BREs (convenience) */
#define	REG_EXTENDED   000001 /* EREs */
#define	REG_ADVF   000002 /* advanced features in EREs */
#define	REG_ADVANCED   000003 /* AREs (which are also EREs) */
#define	REG_QUOTE   000004 /* no special characters, none */
#define	REG_NOSPEC   REG_QUOTE /* historical synonym */
#define	REG_ICASE   000010 /* ignore case */
#define	REG_NOSUB   000020 /* caller doesn't need subexpr match data */
#define	REG_EXPANDED   000040 /* expanded format, white space & comments */
#define	REG_NLSTOP   000100 /* \n doesn't match . or [^ ] */
#define	REG_NLANCH   000200 /* ^ matches after \n, $ before */
#define	REG_NEWLINE   000300 /* newlines are line terminators */
#define	REG_PEND   000400 /* ugh -- backward-compatibility hack */
#define	REG_EXPECT   001000 /* report details on partial/limited matches */
#define	REG_BOSONLY   002000 /* temporary kludge for BOS-only matches */
#define	REG_DUMP   004000 /* none of your business :-) */
#define	REG_FAKE   010000 /* none of your business :-) */
#define	REG_PROGRESS   020000 /* none of your business :-) */
#define	REG_NOTBOL   0001 /* BOS is not BOL */
#define	REG_NOTEOL   0002 /* EOS is not EOL */
#define	REG_STARTEND   0004 /* backward compatibility kludge */
#define	REG_FTRACE   0010 /* none of your business */
#define	REG_MTRACE   0020 /* none of your business */
#define	REG_SMALL   0040 /* none of your business */
#define	REG_OKAY   0 /* no errors detected */
#define	REG_NOMATCH   1 /* failed to match */
#define	REG_BADPAT   2 /* invalid regexp */
#define	REG_ECOLLATE   3 /* invalid collating element */
#define	REG_ECTYPE   4 /* invalid character class */
#define	REG_EESCAPE   5 /* invalid escape \ sequence */
#define	REG_ESUBREG   6 /* invalid backreference number */
#define	REG_EBRACK   7 /* brackets [] not balanced */
#define	REG_EPAREN   8 /* parentheses () not balanced */
#define	REG_EBRACE   9 /* braces {} not balanced */
#define	REG_BADBR   10 /* invalid repetition count(s) */
#define	REG_ERANGE   11 /* invalid character range */
#define	REG_ESPACE   12 /* out of memory */
#define	REG_BADRPT   13 /* quantifier operand invalid */
#define	REG_ASSERT   15 /* "can't happen" -- you found a bug */
#define	REG_INVARG   16 /* invalid argument to regex function */
#define	REG_MIXED   17 /* character widths of regex and string differ */
#define	REG_BADOPT   18 /* invalid embedded option */
#define	REG_ETOOBIG   19 /* regular expression is too complex */
#define	REG_ECOLORS   20 /* too many colors */
#define	REG_CANCEL   21 /* operation cancelled */
#define	REG_ATOI   101 /* convert error-code name to number */
#define	REG_ITOA   102 /* convert error-code number to name */
#define	REG_PREFIX   (-1) /* identified a common prefix */
#define	REG_EXACT   (-2) /* identified an exact match */

Typedefs
typedef long	regoff_t

Functions
int	pg_regcomp (regex_t *, const pg_wchar *, size_t, int, Oid)
int	pg_regexec (regex_t *, const pg_wchar *, size_t, size_t, rm_detail_t *, size_t, regmatch_t[], int)
int	pg_regprefix (regex_t *, pg_wchar **, size_t *)
void	pg_regfree (regex_t *)
size_t	pg_regerror (int, const regex_t *, char *, size_t)
regex_t *	RE_compile_and_cache (text *text_re, int cflags, Oid collation)
bool	RE_compile_and_execute (text *text_re, char *dat, int dat_len, int cflags, Oid collation, int nmatch, regmatch_t *pmatch)

Macro Definition Documentation

_REGEX_H_

#define _REGEX_H_   /* never again */

Definition at line 2 of file regex.h.

REG_ADVANCED

#define REG_ADVANCED   000003 /* AREs (which are also EREs) */

Definition at line 103 of file regex.h.

REG_ADVF

#define REG_ADVF   000002 /* advanced features in EREs */

Definition at line 102 of file regex.h.

REG_ASSERT

#define REG_ASSERT   15 /* "can't happen" -- you found a bug */

Definition at line 151 of file regex.h.

REG_ATOI

#define REG_ATOI   101 /* convert error-code name to number */

Definition at line 159 of file regex.h.

REG_BADBR

#define REG_BADBR   10 /* invalid repetition count(s) */

Definition at line 147 of file regex.h.

REG_BADOPT

#define REG_BADOPT   18 /* invalid embedded option */

Definition at line 154 of file regex.h.

REG_BADPAT

#define REG_BADPAT   2 /* invalid regexp */

Definition at line 139 of file regex.h.

REG_BADRPT

#define REG_BADRPT   13 /* quantifier operand invalid */

Definition at line 150 of file regex.h.

REG_BASIC

#define REG_BASIC   000000 /* BREs (convenience) */

Definition at line 100 of file regex.h.

REG_BOSONLY

#define REG_BOSONLY   002000 /* temporary kludge for BOS-only matches */

Definition at line 114 of file regex.h.

REG_CANCEL

#define REG_CANCEL   21 /* operation cancelled */

Definition at line 157 of file regex.h.

REG_DUMP

#define REG_DUMP   004000 /* none of your business :-) */

Definition at line 115 of file regex.h.

REG_EBRACE

#define REG_EBRACE   9 /* braces {} not balanced */

Definition at line 146 of file regex.h.

REG_EBRACK

#define REG_EBRACK   7 /* brackets [] not balanced */

Definition at line 144 of file regex.h.

REG_ECOLLATE

#define REG_ECOLLATE   3 /* invalid collating element */

Definition at line 140 of file regex.h.

REG_ECOLORS

#define REG_ECOLORS   20 /* too many colors */

Definition at line 156 of file regex.h.

REG_ECTYPE

#define REG_ECTYPE   4 /* invalid character class */

Definition at line 141 of file regex.h.

REG_EESCAPE

#define REG_EESCAPE   5 /* invalid escape \ sequence */

Definition at line 142 of file regex.h.

REG_EPAREN

#define REG_EPAREN   8 /* parentheses () not balanced */

Definition at line 145 of file regex.h.

REG_ERANGE

#define REG_ERANGE   11 /* invalid character range */

Definition at line 148 of file regex.h.

REG_ESPACE

#define REG_ESPACE   12 /* out of memory */

Definition at line 149 of file regex.h.

REG_ESUBREG

#define REG_ESUBREG   6 /* invalid backreference number */

Definition at line 143 of file regex.h.

REG_ETOOBIG

#define REG_ETOOBIG   19 /* regular expression is too complex */

Definition at line 155 of file regex.h.

REG_EXACT

#define REG_EXACT   (-2) /* identified an exact match */

Definition at line 163 of file regex.h.

REG_EXPANDED

#define REG_EXPANDED   000040 /* expanded format, white space & comments */

Definition at line 108 of file regex.h.

REG_EXPECT

#define REG_EXPECT   001000 /* report details on partial/limited matches */

Definition at line 113 of file regex.h.

REG_EXTENDED

#define REG_EXTENDED   000001 /* EREs */

Definition at line 101 of file regex.h.

REG_FAKE

#define REG_FAKE   010000 /* none of your business :-) */

Definition at line 116 of file regex.h.

REG_FTRACE

#define REG_FTRACE   0010 /* none of your business */

Definition at line 127 of file regex.h.

REG_ICASE

#define REG_ICASE   000010 /* ignore case */

Definition at line 106 of file regex.h.

REG_INVARG

#define REG_INVARG   16 /* invalid argument to regex function */

Definition at line 152 of file regex.h.

REG_ITOA

#define REG_ITOA   102 /* convert error-code number to name */

Definition at line 160 of file regex.h.

REG_MIXED

#define REG_MIXED   17 /* character widths of regex and string differ */

Definition at line 153 of file regex.h.

REG_MTRACE

#define REG_MTRACE   0020 /* none of your business */

Definition at line 128 of file regex.h.

REG_NEWLINE

#define REG_NEWLINE   000300 /* newlines are line terminators */

Definition at line 111 of file regex.h.

REG_NLANCH

#define REG_NLANCH   000200 /* ^ matches after \n, $ before */

Definition at line 110 of file regex.h.

REG_NLSTOP

#define REG_NLSTOP   000100 /* \n doesn't match . or [^ ] */

Definition at line 109 of file regex.h.

REG_NOMATCH

#define REG_NOMATCH   1 /* failed to match */

Definition at line 138 of file regex.h.

REG_NOSPEC

#define REG_NOSPEC   REG_QUOTE /* historical synonym */

Definition at line 105 of file regex.h.

REG_NOSUB

#define REG_NOSUB   000020 /* caller doesn't need subexpr match data */

Definition at line 107 of file regex.h.

REG_NOTBOL

#define REG_NOTBOL   0001 /* BOS is not BOL */

Definition at line 124 of file regex.h.

REG_NOTEOL

#define REG_NOTEOL   0002 /* EOS is not EOL */

Definition at line 125 of file regex.h.

REG_OKAY

#define REG_OKAY   0 /* no errors detected */

Definition at line 137 of file regex.h.

REG_PEND

#define REG_PEND   000400 /* ugh -- backward-compatibility hack */

Definition at line 112 of file regex.h.

REG_PREFIX

#define REG_PREFIX   (-1) /* identified a common prefix */

Definition at line 162 of file regex.h.

REG_PROGRESS

#define REG_PROGRESS   020000 /* none of your business :-) */

Definition at line 117 of file regex.h.

REG_QUOTE

#define REG_QUOTE   000004 /* no special characters, none */

Definition at line 104 of file regex.h.

REG_SMALL

#define REG_SMALL   0040 /* none of your business */

Definition at line 129 of file regex.h.

REG_STARTEND

#define REG_STARTEND   0004 /* backward compatibility kludge */

Definition at line 126 of file regex.h.

REG_UBACKREF

#define REG_UBACKREF   000001 /* has back-reference (\n) */

Definition at line 60 of file regex.h.

REG_UBBS

#define REG_UBBS   000100 /* has backslash within bracket expr */

Definition at line 66 of file regex.h.

REG_UBOUNDS

#define REG_UBOUNDS   000004 /* has bounded quantifier ({m,n}) */

Definition at line 62 of file regex.h.

REG_UBRACES

#define REG_UBRACES   000010 /* has { that doesn't begin a quantifier */

Definition at line 63 of file regex.h.

REG_UBSALNUM

#define REG_UBSALNUM   000020 /* has backslash-alphanumeric in non-ARE */

Definition at line 64 of file regex.h.

REG_UEMPTYMATCH

#define REG_UEMPTYMATCH   004000 /* can match a zero-length string */

Definition at line 71 of file regex.h.

REG_UIMPOSSIBLE

#define REG_UIMPOSSIBLE   010000 /* provably cannot match anything */

Definition at line 72 of file regex.h.

REG_ULOCALE

#define REG_ULOCALE   002000 /* has locale dependency */

Definition at line 70 of file regex.h.

REG_ULOOKAROUND

#define REG_ULOOKAROUND   000002 /* has lookahead/lookbehind constraint */

Definition at line 61 of file regex.h.

REG_UNONPOSIX

#define REG_UNONPOSIX   000200 /* has any construct that extends POSIX */

Definition at line 67 of file regex.h.

REG_UPBOTCH

#define REG_UPBOTCH

Value:

                                     000040 /* has unmatched right paren in ERE (legal
                                     * per spec, but that was a mistake) */

Definition at line 65 of file regex.h.

REG_USHORTEST

#define REG_USHORTEST   020000 /* has non-greedy quantifier */

Definition at line 73 of file regex.h.

REG_UUNPORT

#define REG_UUNPORT   001000 /* has numeric character code dependency */

Definition at line 69 of file regex.h.

REG_UUNSPEC

#define REG_UUNSPEC

Value:

                                     000400 /* has any case disallowed by POSIX, e.g.
                                     * an empty branch */

Definition at line 68 of file regex.h.

Typedef Documentation

regoff_t

typedef long regoff_t

Definition at line 48 of file regex.h.

Function Documentation

pg_regcomp()

int pg_regcomp	(	regex_t *	re,
		const pg_wchar *	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_regerror()

size_t pg_regerror	(	int	errcode,
		const regex_t *	preg,
		char *	errbuf,
		size_t	errbuf_size
	)

Definition at line 60 of file regerror.c.

{
    const struct rerr *r;
    const char *msg;
    char        convbuf[sizeof(unk) + 50];  /* 50 = plenty for int */
    size_t      len;
    int         icode;
 
    switch (errcode)
    {
        case REG_ATOI:          /* convert name to number */
            for (r = rerrs; r->code >= 0; r++)
                if (strcmp(r->name, errbuf) == 0)
                    break;
            sprintf(convbuf, "%d", r->code);    /* -1 for unknown */
            msg = convbuf;
            break;
        case REG_ITOA:          /* convert number to name */
            icode = atoi(errbuf);   /* not our problem if this fails */
            for (r = rerrs; r->code >= 0; r++)
                if (r->code == icode)
                    break;
            if (r->code >= 0)
                msg = r->name;
            else
            {                   /* unknown; tell him the number */
                sprintf(convbuf, "REG_%u", (unsigned) icode);
                msg = convbuf;
            }
            break;
        default:                /* a real, normal error code */
            for (r = rerrs; r->code >= 0; r++)
                if (r->code == errcode)
                    break;
            if (r->code >= 0)
                msg = r->explain;
            else
            {                   /* unknown; say so */
                sprintf(convbuf, unk, errcode);
                msg = convbuf;
            }
            break;
    }
 
    len = strlen(msg) + 1;      /* space needed, including NUL */
    if (errbuf_size > 0)
    {
        if (errbuf_size > len)
            strcpy(errbuf, msg);
        else
        {                       /* truncate to fit */
            memcpy(errbuf, msg, errbuf_size - 1);
            errbuf[errbuf_size - 1] = '\0';
        }
    }
 
    return len;
}

References rerr::code, errcode(), rerr::explain, len, rerr::name, REG_ATOI, REG_ITOA, rerrs, sprintf, and unk.

Referenced by check_ident_usermap(), NIAddAffix(), parse_ident_line(), RE_compile(), RE_compile_and_cache(), RE_wchar_execute(), regexp_fixed_prefix(), replace_text_regexp(), test_re_compile(), and test_re_execute().

pg_regexec()

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

Definition at line 176 of file regexec.c.

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

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

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

pg_regfree()

void pg_regfree

(

regex_t *

re

)

Definition at line 49 of file regfree.c.

{
    if (re == NULL)
        return;
    (*((struct fns *) re->re_fns)->free) (re);
}

References regex_t::re_fns.

Referenced by createTrgmNFA(), load_ident(), RE_compile_and_cache(), regex_affix_deletion_callback(), and test_regex().

pg_regprefix()

int pg_regprefix	(	regex_t *	re,
		pg_wchar **	string,
		size_t *	slength
	)

Definition at line 46 of file regprefix.c.

{
    struct guts *g;
    struct cnfa *cnfa;
    int         st;
 
    /* sanity checks */
    if (string == NULL || slength == NULL)
        return REG_INVARG;
    *string = NULL;             /* initialize for failure cases */
    *slength = 0;
    if (re == NULL || re->re_magic != REMAGIC)
        return REG_INVARG;
    if (re->re_csize != sizeof(chr))
        return REG_MIXED;
 
    /* Initialize locale-dependent support */
    pg_set_regex_collation(re->re_collation);
 
    /* setup */
    g = (struct guts *) re->re_guts;
    if (g->info & REG_UIMPOSSIBLE)
        return REG_NOMATCH;
 
    /*
     * This implementation considers only the search NFA for the topmost regex
     * tree node.  Therefore, constraints such as backrefs are not fully
     * applied, which is allowed per the function's API spec.
     */
    assert(g->tree != NULL);
    cnfa = &g->tree->cnfa;
 
    /* matchall NFAs never have a fixed prefix */
    if (cnfa->flags & MATCHALL)
        return REG_NOMATCH;
 
    /*
     * Since a correct NFA should never contain any exit-free loops, it should
     * not be possible for our traversal to return to a previously visited NFA
     * state.  Hence we need at most nstates chrs in the output string.
     */
    *string = (chr *) MALLOC(cnfa->nstates * sizeof(chr));
    if (*string == NULL)
        return REG_ESPACE;
 
    /* do it */
    st = findprefix(cnfa, &g->cmap, *string, slength);
 
    assert(*slength <= cnfa->nstates);
 
    /* clean up */
    if (st != REG_PREFIX && st != REG_EXACT)
    {
        FREE(*string);
        *string = NULL;
        *slength = 0;
    }
 
    return st;
}

References assert, guts::cmap, subre::cnfa, findprefix(), cnfa::flags, FREE, if(), guts::info, MALLOC, MATCHALL, cnfa::nstates, pg_set_regex_collation(), regex_t::re_collation, regex_t::re_csize, regex_t::re_guts, regex_t::re_magic, REG_ESPACE, REG_EXACT, REG_INVARG, REG_MIXED, REG_NOMATCH, REG_PREFIX, REG_UIMPOSSIBLE, REMAGIC, and guts::tree.

Referenced by regexp_fixed_prefix().

RE_compile_and_cache()

regex_t* RE_compile_and_cache	(	text *	text_re,
		int	cflags,
		Oid	collation
	)

Definition at line 138 of file regexp.c.

{
    int         text_re_len = VARSIZE_ANY_EXHDR(text_re);
    char       *text_re_val = VARDATA_ANY(text_re);
    pg_wchar   *pattern;
    int         pattern_len;
    int         i;
    int         regcomp_result;
    cached_re_str re_temp;
    char        errMsg[100];
 
    /*
     * Look for a match among previously compiled REs.  Since the data
     * structure is self-organizing with most-used entries at the front, our
     * search strategy can just be to scan from the front.
     */
    for (i = 0; i < num_res; i++)
    {
        if (re_array[i].cre_pat_len == text_re_len &&
            re_array[i].cre_flags == cflags &&
            re_array[i].cre_collation == collation &&
            memcmp(re_array[i].cre_pat, text_re_val, text_re_len) == 0)
        {
            /*
             * Found a match; move it to front if not there already.
             */
            if (i > 0)
            {
                re_temp = re_array[i];
                memmove(&re_array[1], &re_array[0], i * sizeof(cached_re_str));
                re_array[0] = re_temp;
            }
 
            return &re_array[0].cre_re;
        }
    }
 
    /*
     * Couldn't find it, so try to compile the new RE.  To avoid leaking
     * resources on failure, we build into the re_temp local.
     */
 
    /* Convert pattern string to wide characters */
    pattern = (pg_wchar *) palloc((text_re_len + 1) * sizeof(pg_wchar));
    pattern_len = pg_mb2wchar_with_len(text_re_val,
                                       pattern,
                                       text_re_len);
 
    regcomp_result = pg_regcomp(&re_temp.cre_re,
                                pattern,
                                pattern_len,
                                cflags,
                                collation);
 
    pfree(pattern);
 
    if (regcomp_result != REG_OKAY)
    {
        /* re didn't compile (no need for pg_regfree, if so) */
 
        /*
         * Here and in other places in this file, do CHECK_FOR_INTERRUPTS
         * before reporting a regex error.  This is so that if the regex
         * library aborts and returns REG_CANCEL, we don't print an error
         * message that implies the regex was invalid.
         */
        CHECK_FOR_INTERRUPTS();
 
        pg_regerror(regcomp_result, &re_temp.cre_re, errMsg, sizeof(errMsg));
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
                 errmsg("invalid regular expression: %s", errMsg)));
    }
 
    /*
     * We use malloc/free for the cre_pat field because the storage has to
     * persist across transactions, and because we want to get control back on
     * out-of-memory.  The Max() is because some malloc implementations return
     * NULL for malloc(0).
     */
    re_temp.cre_pat = malloc(Max(text_re_len, 1));
    if (re_temp.cre_pat == NULL)
    {
        pg_regfree(&re_temp.cre_re);
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory")));
    }
    memcpy(re_temp.cre_pat, text_re_val, text_re_len);
    re_temp.cre_pat_len = text_re_len;
    re_temp.cre_flags = cflags;
    re_temp.cre_collation = collation;
 
    /*
     * Okay, we have a valid new item in re_temp; insert it into the storage
     * array.  Discard last entry if needed.
     */
    if (num_res >= MAX_CACHED_RES)
    {
        --num_res;
        Assert(num_res < MAX_CACHED_RES);
        pg_regfree(&re_array[num_res].cre_re);
        free(re_array[num_res].cre_pat);
    }
 
    if (num_res > 0)
        memmove(&re_array[1], &re_array[0], num_res * sizeof(cached_re_str));
 
    re_array[0] = re_temp;
    num_res++;
 
    return &re_array[0].cre_re;
}

References Assert(), CHECK_FOR_INTERRUPTS, cached_re_str::cre_collation, cached_re_str::cre_flags, cached_re_str::cre_pat, cached_re_str::cre_pat_len, cached_re_str::cre_re, ereport, errcode(), errmsg(), ERROR, free, i, malloc, Max, MAX_CACHED_RES, num_res, palloc(), pfree(), pg_mb2wchar_with_len(), pg_regcomp(), pg_regerror(), pg_regfree(), re_array, REG_OKAY, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by RE_compile_and_execute(), regexp_fixed_prefix(), replace_text_regexp(), setup_regexp_matches(), and textregexsubstr().

RE_compile_and_execute()

bool RE_compile_and_execute	(	text *	text_re,
		char *	dat,
		int	dat_len,
		int	cflags,
		Oid	collation,
		int	nmatch,
		regmatch_t *	pmatch
	)

Definition at line 344 of file regexp.c.

{
    regex_t    *re;
 
    /* Use REG_NOSUB if caller does not want sub-match details */
    if (nmatch < 2)
        cflags |= REG_NOSUB;
 
    /* Compile RE */
    re = RE_compile_and_cache(text_re, cflags, collation);
 
    return RE_execute(re, dat, dat_len, nmatch, pmatch);
}

References RE_compile_and_cache(), RE_execute(), and REG_NOSUB.

Referenced by executeLikeRegex(), nameicregexeq(), nameicregexne(), nameregexeq(), nameregexne(), regexp_like(), texticregexeq(), texticregexne(), textregexeq(), and textregexne().