RE_compile(&regex,text_re,REG_ADVANCED |REG_ICASE,collation);

RE_compile(&regex,text_re,

REG_ADVANCED |REG_NOSUB |REG_ICASE,collation);

RE_compile(&regex,text_re,REG_ADVANCED,collation);

RE_compile(&regex,text_re,

REG_ADVANCED |REG_NOSUB,collation);

}

assert(NOTREACHED);

}

if (v->cflags&REG_NOSUB)

RETV('(',0);/* all parens non-capturing */

RETV('(',1);

RETV('(',1);

break;

caseCHR(')'):

if (LASTTYPE('('))

staticvoidfreesubre(structvars*,structsubre*);

staticvoidfreesubreandsiblings(structvars*,structsubre*);

staticvoidfreesrnode(structvars*,structsubre*);

staticvoidoptst(structvars*,structsubre*);

staticvoidremovecaptures(structvars*,structsubre*);

staticintnumst(structsubre*,int);

staticvoidmarkst(structsubre*);

staticvoidcleanst(structvars*);

dumpst(v->tree,debug,1);

}

optst(v,v->tree);

if (v->cflags&REG_NOSUB)

removecaptures(v,v->tree);

v->ntree=numst(v->tree,1);

markst(v->tree);

cleanst(v);

break;

caseBACKREF:/* the Feature From The Black Lagoon */

INSIST(type!=LACON,REG_ESUBREG);

INSIST(v->nextvalue<v->nsubs,REG_ESUBREG);

INSIST(v->subs[v->nextvalue]!=NULL,REG_ESUBREG);

subno=v->nextvalue;

assert(subno>0);

INSIST(subno<v->nsubs,REG_ESUBREG);

NOERRN();

INSIST(v->subs[subno]!=NULL,REG_ESUBREG);

NOERRN();

assert(v->nextvalue>0);

atom=subre(v,'b',BACKR,lp,rp);

NOERRN();

subno=v->nextvalue;

atom->backno=subno;

v->subs[subno]->flags |=BRUSE;

EMPTYARC(lp,rp);/* temporarily, so there's something */

NEXT();

break;

}

optst(structvars*v,

structsubre*t)

removecaptures(structvars*v,

structsubre*t)

{

structsubre*t2;

assert(t!=NULL);

if (!(t->flags&BRUSE))

{

t->capno=0;

t->flags &= ~CAP;

}

for (t2=t->child;t2!=NULL;t2=t2->sibling)

{

removecaptures(v,t2);

if (t2->flags&CAP)

t->flags |=CAP;

}

return;

if ((t->flags& (CAP |BACKR))==0)

{

if (t->child)

freesubreandsiblings(v,t->child);

t->child=NULL;

t->op='=';

t->flags &= ~MIXED;

}

}

fprintf(f," hascapture");

if (t->flags&BACKR)

fprintf(f," hasbackref");

if (t->flags&BRUSE)

fprintf(f," isreferenced");

if (!(t->flags&INUSE))

fprintf(f," UNUSED");

if (t->latype!= (char)-1)

returnREG_NOMATCH;

backref= (v->g->info&REG_UBACKREF) ?1 :0;

v->eflags=flags;

if (v->g->cflags&REG_NOSUB)

nmatch=0;/* override client */

v->nmatch=nmatch;

if (backref)

if (backref&&nmatch <=v->g->nsub)

{

if (v->g->nsub+1 <=LOCALMAT)

v->pmatch=mat;

v->nmatch=v->g->nsub+1;

}

{

v->pmatch=pmatch;

if (nmatch>0)

zapallsubs(pmatch,nmatch);

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;

st=find(v,&v->g->tree->cnfa,&v->g->cmap);

if (st==REG_OKAY&&v->pmatch!=pmatch&&nmatch>0)

if (st==REG_OKAY&&nmatch>0)

{

zapallsubs(pmatch,nmatch);

n= (nmatch<v->nmatch) ?nmatch :v->nmatch;

memcpy(VS(pmatch),VS(v->pmatch),n*sizeof(regmatch_t));

if (v->pmatch!=pmatch)

{

assert(nmatch <=v->nmatch);

memcpy(VS(pmatch),VS(v->pmatch),nmatch*sizeof(regmatch_t));

}

if (v->g->cflags&REG_NOSUB)

{

zapallsubs(pmatch,nmatch);

}

}

break;

case'(':/* no-op capture node */

assert(t->child!=NULL);

assert(t->capno>0);

er=cdissect(v,t->child,begin,end);

break;

default:

errmsg("XQuery\"x\" flag (expanded regular expressions) is not implemented")));

}

cflags |= REG_NOSUB;

return cflags;

}

{

regex_t*re;

if (nmatch<2)

cflags |=REG_NOSUB;

re=RE_compile_and_cache(text_re,cflags,collation);

intorig_len;

pg_wchar*wide_str;

intwide_len;

intcflags;

regex_t*cpattern;

regmatch_t*pmatch;

intpmatch_len;

wide_len=pg_mb2wchar_with_len(VARDATA_ANY(orig_str),wide_str,orig_len);

cpattern=RE_compile_and_cache(pattern,re_flags->cflags,collation);

cflags=re_flags->cflags;

if (!use_subpatterns)

cflags |=REG_NOSUB;

cpattern=RE_compile_and_cache(pattern,cflags,collation);

if (use_subpatterns&&cpattern->re_nsub>0)

if (case_insensitive)

cflags |=REG_ICASE;

re=RE_compile_and_cache(text_re,cflags,collation);

re=RE_compile_and_cache(text_re,cflags |REG_NOSUB,collation);

re_result=pg_regprefix(re,&str,&slen);

#defineREG_QUOTE000004/* no special characters, none */

#defineREG_NOSPECREG_QUOTE/* historical synonym */

#defineREG_ICASE000010/* ignore case */

#defineREG_NOSUB000020/*don'tcare about subexpressions */

#defineREG_NOSUB000020/*caller doesn'tneed subexpr match data */

#defineREG_EXPANDED000040/* expanded format, white space & comments */

#defineREG_NLSTOP000100/* \n doesn't match . or [^ ] */

#defineREG_NLANCH000200/* ^ matches after \n, $ before */

#defineMIXED 04/* mixed preference below */

#defineCAP 010/* capturing parens here or below */

#defineBACKR 020/* back reference here or below */

#defineBRUSE 040/* is referenced by a back reference */

#defineINUSE 0100/* in use in final tree */

#defineLMIX(f) ((f)<<2)/* LONGER -> MIXED */

#defineSMIX(f) ((f)<<1)/* SHORTER -> MIXED */

#defineUP(f) (((f)&~NOPROP) | (LMIX(f) & SMIX(f) & MIXED))

#defineUP(f) (((f)&UPPROP) | (LMIX(f) & SMIX(f) & MIXED))

#defineMESSY(f) ((f)&(MIXED|CAP|BACKR))

#definePREF(f) ((f)&NOPROP)

#definePREF(f) ((f)&(LONGER|SHORTER))

#definePREF2(f1,f2) ((PREF(f1) != 0) ? PREF(f1) : PREF(f2))

#defineCOMBINE(f1,f2) (UP((f1)|(f2)) | PREF2(f1, f2))

charlatype;/* LATYPE code, if lookaround constraint */

{ae,a}

(2 rows)

-- expectMatch4.2o(a)eae

select * from test_regex('(a)e', 'ae', 'o');

test_regex

------------

{0}

{NULL}

-- expectMatch4.2oPR(.)\1eabeaaeaae{}

select * from test_regex('(.)\1e', 'abeaae', 'oPR');

test_regex

--------------------------------

{1,REG_UBACKREF,REG_UNONPOSIX}

{aae,NULL}

(2 rows)

-- expectMatch4.3 b{\(a\)b}ababa

{"abc abc",abc}

(2 rows)

-- exercise oversize-regmatch_t-array paths in regexec()

-- (that case is not reachable via test_regex, sadly)

select substring('fffoooooooooooooooooooooooooooooooo', '^(.)\1(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)');

substring

-----------

f

(1 row)

select regexp_split_to_array('abcxxxdefyyyghi', '((.))(\1\2)');

regexp_split_to_array

-----------------------

{abc,def,ghi}

(1 row)

-- doing 15 "octal escapes vs back references"

-- # initial zero is always octal

-- expectMatch15.1 MP"a\\010b""a\bb""a\bb"

{x,x,x,NULL}

(2 rows)

-- expectMatch21.37 RP((.))(\2)xyyyyyyy

select * from test_regex('((.))(\2)', 'xyy', 'RP');

test_regex

--------------------------------

{3,REG_UBACKREF,REG_UNONPOSIX}

{yy,y,y,y}

(2 rows)

-- expectMatch21.38 oRP((.))(\2)xyyyy{}{}{}

select * from test_regex('((.))(\2)', 'xyy', 'oRP');

test_regex

--------------------------------

{3,REG_UBACKREF,REG_UNONPOSIX}

{yy,NULL,NULL,NULL}

(2 rows)

-- doing 22 "multicharacter collating elements"

-- # again ugh

-- MCCEs are not implemented in Postgres, so we skip all these tests

select*from test_regex('(a)e','ae','-');

select*from test_regex('(a)e','ae','o');

select*from test_regex('(.)\1e','abeaae','oPR');

select*from test_regex('\(a\)b','ab','b');

select*from test_regex('(^\w+\M).*\1','abc abcd abd','LRP');

select*from test_regex('(\w+(?= )).*\1','abc abcd abd','HLRP');

selectsubstring('fffoooooooooooooooooooooooooooooooo','^(.)\1(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)');

select regexp_split_to_array('abcxxxdefyyyghi','((.))(\1\2)');

select*from test_regex(' TO (([a-z0-9._]+|"([^"]+|"")+")+)','asd TO foo','M');

select*from test_regex('((.))(\2){0}','xy','RPQ');

select*from test_regex('((.))(\2)','xyy','RP');

select*from test_regex('((.))(\2)','xyy','oRP');