test_regex.c File Reference

#include "postgres.h"
#include "catalog/pg_type_d.h"
#include "funcapi.h"
#include "regex/regex.h"
#include "utils/array.h"
#include "utils/builtins.h"

Include dependency graph for test_regex.c:

Go to the source code of this file.

Data Structures
struct	test_re_flags
struct	test_regex_ctx

Typedefs
typedef struct test_re_flags	test_re_flags
typedef struct test_regex_ctx	test_regex_ctx

Functions
static void	test_re_compile (text *text_re, int cflags, Oid collation, regex_t *result_re)
static void	parse_test_flags (test_re_flags *flags, text *opts)
static test_regex_ctx *	setup_test_matches (text *orig_str, regex_t *cpattern, test_re_flags *re_flags, Oid collation, bool use_subpatterns)
static ArrayType *	build_test_info_result (regex_t *cpattern, test_re_flags *flags)
static ArrayType *	build_test_match_result (test_regex_ctx *matchctx)
	PG_FUNCTION_INFO_V1 (test_regex)
Datum	test_regex (PG_FUNCTION_ARGS)
static bool	test_re_execute (regex_t *re, pg_wchar *data, int data_len, int start_search, rm_detail_t *details, int nmatch, regmatch_t *pmatch, int eflags)

Variables
	PG_MODULE_MAGIC

Typedef Documentation

test_re_flags

typedef struct test_re_flags test_re_flags

test_regex_ctx

typedef struct test_regex_ctx test_regex_ctx

Function Documentation

build_test_info_result()

static ArrayType * build_test_info_result ( regex_t *  cpattern, test_re_flags *  flags  )

static

Definition at line 617 of file test_regex.c.

{
    /* Translation data for flag bits in regex_t.re_info */
    struct infoname
    {
        int         bit;
        const char *text;
    };
    static const struct infoname infonames[] = {
        {REG_UBACKREF, "REG_UBACKREF"},
        {REG_ULOOKAROUND, "REG_ULOOKAROUND"},
        {REG_UBOUNDS, "REG_UBOUNDS"},
        {REG_UBRACES, "REG_UBRACES"},
        {REG_UBSALNUM, "REG_UBSALNUM"},
        {REG_UPBOTCH, "REG_UPBOTCH"},
        {REG_UBBS, "REG_UBBS"},
        {REG_UNONPOSIX, "REG_UNONPOSIX"},
        {REG_UUNSPEC, "REG_UUNSPEC"},
        {REG_UUNPORT, "REG_UUNPORT"},
        {REG_ULOCALE, "REG_ULOCALE"},
        {REG_UEMPTYMATCH, "REG_UEMPTYMATCH"},
        {REG_UIMPOSSIBLE, "REG_UIMPOSSIBLE"},
        {REG_USHORTEST, "REG_USHORTEST"},
        {0, NULL}
    };
    const struct infoname *inf;
    Datum       elems[lengthof(infonames) + 1];
    int         nresults = 0;
    char        buf[80];
    int         dims[1];
    int         lbs[1];
 
    /* Set up results: first, the number of subexpressions */
    snprintf(buf, sizeof(buf), "%d", (int) cpattern->re_nsub);
    elems[nresults++] = PointerGetDatum(cstring_to_text(buf));
 
    /* Report individual info bit states */
    for (inf = infonames; inf->bit != 0; inf++)
    {
        if (cpattern->re_info & inf->bit)
        {
            if (flags->info & inf->bit)
                elems[nresults++] = PointerGetDatum(cstring_to_text(inf->text));
            else
            {
                snprintf(buf, sizeof(buf), "unexpected %s!", inf->text);
                elems[nresults++] = PointerGetDatum(cstring_to_text(buf));
            }
        }
        else
        {
            if (flags->info & inf->bit)
            {
                snprintf(buf, sizeof(buf), "missing %s!", inf->text);
                elems[nresults++] = PointerGetDatum(cstring_to_text(buf));
            }
        }
    }
 
    /* And form an array */
    dims[0] = nresults;
    lbs[0] = 1;
    /* XXX: this hardcodes assumptions about the text type */
    return construct_md_array(elems, NULL, 1, dims, lbs,
                              TEXTOID, -1, false, TYPALIGN_INT);
}

References bit(), buf, construct_md_array(), cstring_to_text(), fb(), test_re_flags::info, lengthof, PointerGetDatum(), REG_UBACKREF, REG_UBBS, REG_UBOUNDS, REG_UBRACES, REG_UBSALNUM, REG_UEMPTYMATCH, REG_UIMPOSSIBLE, REG_ULOCALE, REG_ULOOKAROUND, REG_UNONPOSIX, REG_UPBOTCH, REG_USHORTEST, REG_UUNPORT, REG_UUNSPEC, and snprintf.

Referenced by test_regex().

build_test_match_result()

static ArrayType * build_test_match_result ( test_regex_ctx *  matchctx )

static

Definition at line 691 of file test_regex.c.

{
    char       *buf = matchctx->conv_buf;
    Datum      *elems = matchctx->elems;
    bool       *nulls = matchctx->nulls;
    bool        indices = matchctx->re_flags.indices;
    char        bufstr[80];
    int         dims[1];
    int         lbs[1];
    int         loc;
    int         i;
 
    /* Extract matching substrings from the original string */
    loc = matchctx->next_match * matchctx->npatterns * 2;
    for (i = 0; i < matchctx->npatterns; i++)
    {
        int         so = matchctx->match_locs[loc++];
        int         eo = matchctx->match_locs[loc++];
 
        if (indices)
        {
            /* Report eo this way for consistency with Tcl */
            snprintf(bufstr, sizeof(bufstr), "%d %d",
                     so, so < 0 ? eo : eo - 1);
            elems[i] = PointerGetDatum(cstring_to_text(bufstr));
            nulls[i] = false;
        }
        else if (so < 0 || eo < 0)
        {
            elems[i] = (Datum) 0;
            nulls[i] = true;
        }
        else if (buf)
        {
            int         len = pg_wchar2mb_with_len(matchctx->wide_str + so,
                                                   buf,
                                                   eo - so);
 
            Assert(len < matchctx->conv_bufsiz);
            elems[i] = PointerGetDatum(cstring_to_text_with_len(buf, len));
            nulls[i] = false;
        }
        else
        {
            elems[i] = DirectFunctionCall3(text_substr,
                                           PointerGetDatum(matchctx->orig_str),
                                           Int32GetDatum(so + 1),
                                           Int32GetDatum(eo - so));
            nulls[i] = false;
        }
    }
 
    /* In EXPECT indices mode, also report the "details" */
    if (indices && (matchctx->re_flags.cflags & REG_EXPECT))
    {
        int         so = matchctx->details.rm_extend.rm_so;
        int         eo = matchctx->details.rm_extend.rm_eo;
 
        snprintf(bufstr, sizeof(bufstr), "%d %d",
                 so, so < 0 ? eo : eo - 1);
        elems[i] = PointerGetDatum(cstring_to_text(bufstr));
        nulls[i] = false;
        i++;
    }
 
    /* And form an array */
    dims[0] = i;
    lbs[0] = 1;
    /* XXX: this hardcodes assumptions about the text type */
    return construct_md_array(elems, nulls, 1, dims, lbs,
                              TEXTOID, -1, false, TYPALIGN_INT);
}

References Assert, buf, construct_md_array(), cstring_to_text(), cstring_to_text_with_len(), DirectFunctionCall3, fb(), i, Int32GetDatum(), len, pg_wchar2mb_with_len(), PointerGetDatum(), REG_EXPECT, snprintf, and text_substr().

Referenced by test_regex().

parse_test_flags()

static void parse_test_flags ( test_re_flags *  flags, text *  opts  )

static

Definition at line 248 of file test_regex.c.

{
    /* these defaults must match Tcl's */
    int         cflags = REG_ADVANCED;
    int         eflags = 0;
    long        info = 0;
 
    flags->glob = false;
    flags->indices = false;
    flags->partial = false;
 
    if (opts)
    {
        char       *opt_p = VARDATA_ANY(opts);
        int         opt_len = VARSIZE_ANY_EXHDR(opts);
        int         i;
 
        for (i = 0; i < opt_len; i++)
        {
            switch (opt_p[i])
            {
                case '-':
                    /* allowed, no-op */
                    break;
                case '!':
                    flags->partial = true;
                    break;
                case '*':
                    /* test requires Unicode --- ignored here */
                    break;
                case '0':
                    flags->indices = true;
                    break;
 
                    /* These flags correspond to user-exposed RE options: */
                case 'g':       /* global match */
                    flags->glob = true;
                    break;
                case 'i':       /* case insensitive */
                    cflags |= REG_ICASE;
                    break;
                case 'n':       /* \n affects ^ $ . [^ */
                    cflags |= REG_NEWLINE;
                    break;
                case 'p':       /* ~Perl, \n affects . [^ */
                    cflags |= REG_NLSTOP;
                    cflags &= ~REG_NLANCH;
                    break;
                case 'w':       /* weird, \n affects ^ $ only */
                    cflags &= ~REG_NLSTOP;
                    cflags |= REG_NLANCH;
                    break;
                case 'x':       /* expanded syntax */
                    cflags |= REG_EXPANDED;
                    break;
 
                    /* These flags correspond to Tcl's -xflags options: */
                case 'a':
                    cflags |= REG_ADVF;
                    break;
                case 'b':
                    cflags &= ~REG_ADVANCED;
                    break;
                case 'c':
 
                    /*
                     * Tcl calls this TCL_REG_CANMATCH, but it's really
                     * REG_EXPECT.  In this implementation we must also set
                     * the partial and indices flags, so that
                     * setup_test_matches and build_test_match_result will
                     * emit the desired data.  (They'll emit more fields than
                     * Tcl would, but that's fine.)
                     */
                    cflags |= REG_EXPECT;
                    flags->partial = true;
                    flags->indices = true;
                    break;
                case 'e':
                    cflags &= ~REG_ADVANCED;
                    cflags |= REG_EXTENDED;
                    break;
                case 'q':
                    cflags &= ~REG_ADVANCED;
                    cflags |= REG_QUOTE;
                    break;
                case 'o':       /* o for opaque */
                    cflags |= REG_NOSUB;
                    break;
                case 's':       /* s for start */
                    cflags |= REG_BOSONLY;
                    break;
                case '+':
                    cflags |= REG_FAKE;
                    break;
                case ',':
                    cflags |= REG_PROGRESS;
                    break;
                case '.':
                    cflags |= REG_DUMP;
                    break;
                case ':':
                    eflags |= REG_MTRACE;
                    break;
                case ';':
                    eflags |= REG_FTRACE;
                    break;
                case '^':
                    eflags |= REG_NOTBOL;
                    break;
                case '$':
                    eflags |= REG_NOTEOL;
                    break;
                case 't':
                    cflags |= REG_EXPECT;
                    break;
                case '%':
                    eflags |= REG_SMALL;
                    break;
 
                    /* These flags define expected info bits: */
                case 'A':
                    info |= REG_UBSALNUM;
                    break;
                case 'B':
                    info |= REG_UBRACES;
                    break;
                case 'E':
                    info |= REG_UBBS;
                    break;
                case 'H':
                    info |= REG_ULOOKAROUND;
                    break;
                case 'I':
                    info |= REG_UIMPOSSIBLE;
                    break;
                case 'L':
                    info |= REG_ULOCALE;
                    break;
                case 'M':
                    info |= REG_UUNPORT;
                    break;
                case 'N':
                    info |= REG_UEMPTYMATCH;
                    break;
                case 'P':
                    info |= REG_UNONPOSIX;
                    break;
                case 'Q':
                    info |= REG_UBOUNDS;
                    break;
                case 'R':
                    info |= REG_UBACKREF;
                    break;
                case 'S':
                    info |= REG_UUNSPEC;
                    break;
                case 'T':
                    info |= REG_USHORTEST;
                    break;
                case 'U':
                    info |= REG_UPBOTCH;
                    break;
 
                default:
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                             errmsg("invalid regular expression test option: \"%.*s\"",
                                    pg_mblen_range(opt_p + i, opt_p + opt_len),
                                    opt_p + i)));
                    break;
            }
        }
    }
    flags->cflags = cflags;
    flags->eflags = eflags;
    flags->info = info;
}

References test_re_flags::cflags, test_re_flags::eflags, ereport, errcode(), errmsg, ERROR, fb(), test_re_flags::glob, i, test_re_flags::indices, test_re_flags::info, opts, test_re_flags::partial, pg_mblen_range(), REG_ADVANCED, REG_ADVF, REG_BOSONLY, REG_DUMP, REG_EXPANDED, REG_EXPECT, REG_EXTENDED, REG_FAKE, REG_FTRACE, REG_ICASE, REG_MTRACE, REG_NEWLINE, REG_NLANCH, REG_NLSTOP, REG_NOSUB, REG_NOTBOL, REG_NOTEOL, REG_PROGRESS, REG_QUOTE, REG_SMALL, REG_UBACKREF, REG_UBBS, REG_UBOUNDS, REG_UBRACES, REG_UBSALNUM, REG_UEMPTYMATCH, REG_UIMPOSSIBLE, REG_ULOCALE, REG_ULOOKAROUND, REG_UNONPOSIX, REG_UPBOTCH, REG_USHORTEST, REG_UUNPORT, REG_UUNSPEC, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by test_regex().

PG_FUNCTION_INFO_V1()

PG_FUNCTION_INFO_V1

(

test_regex

)

setup_test_matches()

static test_regex_ctx * setup_test_matches ( text *  orig_str, regex_t *  cpattern, test_re_flags *  re_flags, Oid  collation, bool  use_subpatterns  )

static

Definition at line 434 of file test_regex.c.

{
    test_regex_ctx *matchctx = palloc0_object(test_regex_ctx);
    int         eml = pg_database_encoding_max_length();
    int         orig_len;
    pg_wchar   *wide_str;
    int         wide_len;
    regmatch_t *pmatch;
    int         pmatch_len;
    int         array_len;
    int         array_idx;
    int         prev_match_end;
    int         start_search;
    int         maxlen = 0;     /* largest fetch length in characters */
 
    /* save flags */
    matchctx->re_flags = *re_flags;
 
    /* save original string --- we'll extract result substrings from it */
    matchctx->orig_str = orig_str;
 
    /* convert string to pg_wchar form for matching */
    orig_len = VARSIZE_ANY_EXHDR(orig_str);
    wide_str = palloc_array(pg_wchar, orig_len + 1);
    wide_len = pg_mb2wchar_with_len(VARDATA_ANY(orig_str), wide_str, orig_len);
 
    /* do we want to remember subpatterns? */
    if (use_subpatterns && cpattern->re_nsub > 0)
    {
        matchctx->npatterns = cpattern->re_nsub + 1;
        pmatch_len = cpattern->re_nsub + 1;
    }
    else
    {
        use_subpatterns = false;
        matchctx->npatterns = 1;
        pmatch_len = 1;
    }
 
    /* temporary output space for RE package */
    pmatch = palloc_array(regmatch_t, pmatch_len);
 
    /*
     * the real output space (grown dynamically if needed)
     *
     * use values 2^n-1, not 2^n, so that we hit the limit at 2^28-1 rather
     * than at 2^27
     */
    array_len = re_flags->glob ? 255 : 31;
    matchctx->match_locs = palloc_array(int, array_len);
    array_idx = 0;
 
    /* search for the pattern, perhaps repeatedly */
    prev_match_end = 0;
    start_search = 0;
    while (test_re_execute(cpattern, wide_str, wide_len,
                           start_search,
                           &matchctx->details,
                           pmatch_len, pmatch,
                           re_flags->eflags))
    {
        /* enlarge output space if needed */
        while (array_idx + matchctx->npatterns * 2 + 1 > array_len)
        {
            array_len += array_len + 1; /* 2^n-1 => 2^(n+1)-1 */
            if (array_len > MaxAllocSize / sizeof(int))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("too many regular expression matches")));
            matchctx->match_locs = (int *) repalloc(matchctx->match_locs,
                                                    sizeof(int) * array_len);
        }
 
        /* save this match's locations */
        for (int i = 0; i < matchctx->npatterns; i++)
        {
            int         so = pmatch[i].rm_so;
            int         eo = pmatch[i].rm_eo;
 
            matchctx->match_locs[array_idx++] = so;
            matchctx->match_locs[array_idx++] = eo;
            if (so >= 0 && eo >= 0 && (eo - so) > maxlen)
                maxlen = (eo - so);
        }
        matchctx->nmatches++;
        prev_match_end = pmatch[0].rm_eo;
 
        /* if not glob, stop after one match */
        if (!re_flags->glob)
            break;
 
        /*
         * Advance search position.  Normally we start the next search at the
         * end of the previous match; but if the match was of zero length, we
         * have to advance by one character, or we'd just find the same match
         * again.
         */
        start_search = prev_match_end;
        if (pmatch[0].rm_so == pmatch[0].rm_eo)
            start_search++;
        if (start_search > wide_len)
            break;
    }
 
    /*
     * If we had no match, but "partial" and "indices" are set, emit the
     * details.
     */
    if (matchctx->nmatches == 0 && re_flags->partial && re_flags->indices)
    {
        /* enlarge output space if needed */
        while (array_idx + matchctx->npatterns * 2 + 1 > array_len)
        {
            array_len += array_len + 1; /* 2^n-1 => 2^(n+1)-1 */
            if (array_len > MaxAllocSize / sizeof(int))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("too many regular expression matches")));
            matchctx->match_locs = (int *) repalloc(matchctx->match_locs,
                                                    sizeof(int) * array_len);
        }
 
        matchctx->match_locs[array_idx++] = matchctx->details.rm_extend.rm_so;
        matchctx->match_locs[array_idx++] = matchctx->details.rm_extend.rm_eo;
        /* we don't have pmatch data, so emit -1 */
        for (int i = 1; i < matchctx->npatterns; i++)
        {
            matchctx->match_locs[array_idx++] = -1;
            matchctx->match_locs[array_idx++] = -1;
        }
        matchctx->nmatches++;
    }
 
    Assert(array_idx <= array_len);
 
    if (eml > 1)
    {
        int64       maxsiz = eml * (int64) maxlen;
        int         conv_bufsiz;
 
        /*
         * Make the conversion buffer large enough for any substring of
         * interest.
         *
         * Worst case: assume we need the maximum size (maxlen*eml), but take
         * advantage of the fact that the original string length in bytes is
         * an upper bound on the byte length of any fetched substring (and we
         * know that len+1 is safe to allocate because the varlena header is
         * longer than 1 byte).
         */
        if (maxsiz > orig_len)
            conv_bufsiz = orig_len + 1;
        else
            conv_bufsiz = maxsiz + 1;   /* safe since maxsiz < 2^30 */
 
        matchctx->conv_buf = palloc(conv_bufsiz);
        matchctx->conv_bufsiz = conv_bufsiz;
        matchctx->wide_str = wide_str;
    }
    else
    {
        /* No need to keep the wide string if we're in a single-byte charset. */
        pfree(wide_str);
        matchctx->wide_str = NULL;
        matchctx->conv_buf = NULL;
        matchctx->conv_bufsiz = 0;
    }
 
    /* Clean up temp storage */
    pfree(pmatch);
 
    return matchctx;
}

References Assert, test_re_flags::eflags, ereport, errcode(), errmsg, ERROR, fb(), test_re_flags::glob, i, test_re_flags::indices, MaxAllocSize, palloc(), palloc0_object, palloc_array, test_re_flags::partial, pfree(), pg_database_encoding_max_length(), pg_mb2wchar_with_len(), regmatch_t, repalloc(), test_re_execute(), VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by test_regex().

test_re_compile()

static void test_re_compile ( text *  text_re, int  cflags, Oid  collation, regex_t *  result_re  )

static

Definition at line 159 of file test_regex.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         regcomp_result;
    char        errMsg[100];
 
    /* 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(result_re,
                                pattern,
                                pattern_len,
                                cflags,
                                collation);
 
    pfree(pattern);
 
    if (regcomp_result != REG_OKAY)
    {
        /* re didn't compile (no need for pg_regfree, if so) */
        pg_regerror(regcomp_result, result_re, errMsg, sizeof(errMsg));
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
                 errmsg("invalid regular expression: %s", errMsg)));
    }
}

References ereport, errcode(), errmsg, ERROR, fb(), palloc(), pfree(), pg_mb2wchar_with_len(), pg_regcomp(), pg_regerror(), REG_OKAY, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by test_regex().

test_re_execute()

static bool test_re_execute ( regex_t *  re, pg_wchar *  data, int  data_len, int  start_search, rm_detail_t *  details, int  nmatch, regmatch_t *  pmatch, int  eflags  )

static

Definition at line 200 of file test_regex.c.

{
    int         regexec_result;
    char        errMsg[100];
 
    /* Initialize match locations in case engine doesn't */
    details->rm_extend.rm_so = -1;
    details->rm_extend.rm_eo = -1;
    for (int i = 0; i < nmatch; i++)
    {
        pmatch[i].rm_so = -1;
        pmatch[i].rm_eo = -1;
    }
 
    /* Perform RE match and return result */
    regexec_result = pg_regexec(re,
                                data,
                                data_len,
                                start_search,
                                details,
                                nmatch,
                                pmatch,
                                eflags);
 
    if (regexec_result != REG_OKAY && regexec_result != REG_NOMATCH)
    {
        /* re failed??? */
        pg_regerror(regexec_result, re, errMsg, sizeof(errMsg));
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
                 errmsg("regular expression failed: %s", errMsg)));
    }
 
    return (regexec_result == REG_OKAY);
}

References data, ereport, errcode(), errmsg, ERROR, fb(), i, pg_regerror(), pg_regexec(), REG_NOMATCH, REG_OKAY, pg_regmatch_t::rm_eo, rm_detail_t::rm_extend, and pg_regmatch_t::rm_so.

Referenced by setup_test_matches().

test_regex()

Datum test_regex

(

PG_FUNCTION_ARGS

)

Definition at line 80 of file test_regex.c.

{
    FuncCallContext *funcctx;
    test_regex_ctx *matchctx;
    ArrayType  *result_ary;
 
    if (SRF_IS_FIRSTCALL())
    {
        text       *pattern = PG_GETARG_TEXT_PP(0);
        text       *flags = PG_GETARG_TEXT_PP(2);
        Oid         collation = PG_GET_COLLATION();
        test_re_flags re_flags;
        regex_t     cpattern;
        MemoryContext oldcontext;
 
        funcctx = SRF_FIRSTCALL_INIT();
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
        /* Determine options */
        parse_test_flags(&re_flags, flags);
 
        /* set up the compiled pattern */
        test_re_compile(pattern, re_flags.cflags, collation, &cpattern);
 
        /* be sure to copy the input string into the multi-call ctx */
        matchctx = setup_test_matches(PG_GETARG_TEXT_P_COPY(1), &cpattern,
                                      &re_flags,
                                      collation,
                                      true);
 
        /* Pre-create workspace that build_test_match_result needs */
        matchctx->elems = palloc_array(Datum, matchctx->npatterns + 1);
        matchctx->nulls = palloc_array(bool, matchctx->npatterns + 1);
 
        MemoryContextSwitchTo(oldcontext);
        funcctx->user_fctx = matchctx;
 
        /*
         * Return the first result row, which is info equivalent to Tcl's
         * "regexp -about" output
         */
        result_ary = build_test_info_result(&cpattern, &re_flags);
 
        pg_regfree(&cpattern);
 
        SRF_RETURN_NEXT(funcctx, PointerGetDatum(result_ary));
    }
    else
    {
        /* Each subsequent row describes one match */
        funcctx = SRF_PERCALL_SETUP();
        matchctx = (test_regex_ctx *) funcctx->user_fctx;
 
        if (matchctx->next_match < matchctx->nmatches)
        {
            result_ary = build_test_match_result(matchctx);
            matchctx->next_match++;
            SRF_RETURN_NEXT(funcctx, PointerGetDatum(result_ary));
        }
    }
 
    SRF_RETURN_DONE(funcctx);
}

References build_test_info_result(), build_test_match_result(), test_re_flags::cflags, fb(), MemoryContextSwitchTo(), palloc_array, parse_test_flags(), PG_GET_COLLATION, PG_GETARG_TEXT_P_COPY, PG_GETARG_TEXT_PP, pg_regfree(), PointerGetDatum(), regex_t, setup_test_matches(), SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, and test_re_compile().

Variable Documentation

PG_MODULE_MAGIC

PG_MODULE_MAGIC

Definition at line 23 of file test_regex.c.