.fp 5 B

.de Af

.ds ;G \\*(;G\\f\\$1\\$3\\f\\$2

.if !\\$4 .Af \\$2 \\$1 "\\$4" "\\$5" "\\$6" "\\$7" "\\$8" "\\$9"

..

.de aF

.ie \\$3 .ft \\$1

.el \{\

.ds ;G \&

.nr ;G \\n(.f

.Af "\\$1" "\\$2" "\\$3" "\\$4" "\\$5" "\\$6" "\\$7" "\\$8" "\\$9"

\\*(;G

.ft \\n(;G \}

..

.de L

.aF 5 \\n(.f "\\$1" "\\$2" "\\$3" "\\$4" "\\$5" "\\$6" "\\$7"

..

.de LR

.aF 5 1 "\\$1" "\\$2" "\\$3" "\\$4" "\\$5" "\\$6" "\\$7"

..

.de RL

.aF 1 5 "\\$1" "\\$2" "\\$3" "\\$4" "\\$5" "\\$6" "\\$7"

..

.de EX \" start example

.ta 1i 2i 3i 4i 5i 6i

.PP

.RS

.PD 0

.ft 5

.nf

..

.de EE \" end example

.fi

.ft

.PD

.RE

.PP

..

.TH REGEX 3

.SH NAME

regex \- regular expression interface

.SH SYNOPSIS

.EX

#include <regex.h>

int regcomp(regex_t* \fIre\fP, const char* \fIregex\fP, int \fIcflags\fP);

int regexec(const regex_t* \fIre\fP, const char* \fIstring\fP, size_t \fInmatch\fP, regmatch_t \fIpmatch\fP[], int \fIeflags\fP);

size_t regerror(int \fIcode\fP, const regex_t* \fIre\fP, char* \fIerrbuf\fP, size_t \fIerrbuf_size\fP);

void regfree(regex_t* \fIre\fP);

regclass_t regclass(const char* \fIstr\fP, char** \fIend\fP);

int regaddclass(const char* \fIname\fP, regclass_t \fIclassf\fP);

int regcollate(const char* \fIstr\fP, char** \fIend\fP, char* \fIbuf\fP, int \fIsize\fP);

int regcomb(regex_t* \fIre_1\fP, regex_t* \fIre_2\fP);

size_t regdecomp(regex_t* \fIre\fP, regflags_t \fIflags\fP, char* \fIbuf\fP, size_t \fIsize\fP);

int regdup(regex_t* \fIre_old\fP, regex_t* \fIre_new\fP);

regstat_t* regstat(const regex_t* \fIre\fP);

regex_t* regcache(const char* \fIpattern\fP, regflags_t \fIflags\fP, int* \fIpcode\fP);

int regncomp(regex_t* \fIre\fP, const char* \fIpattern\fP, size_t \fIsize\fP, regflags_t \fIflags\fP);

int regnexec(const regex_t* \fIre\fP, const char* \fIsubject\fP, size_t \fIsize\fP, size_t \fInmatch\fP, regmatch_t* \fImatch\fP, regflags_t \fIflags\fP);

int regrecord(const regex_t* \fIre\fP);

int regrexec(const regex_t* \fIre\fP, const char* \fIbuf\fP, size_t \fIsize\fP, size_t \fInmatch\fP, regmatch_t* \fImatch\fP, regflags_t \fIflags\fP, int \fIsep\fP, void* \fIhandle\fP, regrecord_t \fIrecordf\fP);

void regfatal(regex_t* \fIre\fP, int \fIlevel\fP, int \fIcode\fP);

void regfatalpat(regex_t* \fIre\fP, int \fIlevel\fP, int \fIcode\fP, const char* \fIpattern\fP);

int regsubcomp(regex_t* \fIre\fP, const char* \fIstr\fP, const regflags_t* \fImap\fP, int \fIminmatch\fP, regflags_t \fIflags\fP);

int regsubexec(const regex_t* \fIre\fP, const char* \fIsubject\fP, size_t \fInmatch\fP, regmatch_t* match);

int regsubflags(regex_t* \fIre\fP, const char* \fIstr\fP, char** \fIend\fP, int \fIdelim\fP, const regflags_t* \fImap\fP, int* \fIpm\fP, regflags_t* \fIpf\fP);

void regsubfree(regex_t* \fIre\fP);

.EE

.SH DESCRIPTION

.LR regcomp() ,

.LR regexec() ,

.LR regerror() ,

and

.L regfree()

are the POSIX regular expression functions.

The remaining functions are

.B ast

extensions.

.B ast

also provides

.I flags

extensions to the

.LR regcomp() ,

.LR regexec()

functions and

.I code

extensions to the

.L regerror()

function.

.PP

.L regcache()

maintains a cache of compiled regular expressions for patterns of size

255 bytes or less.

The initial cache size is 8.

.L pattern

and

.L flags

are passed to

.L regcomp()

with an

.L re

pointer maintained by

.LR regcache() .

.LR pcode ,

if not 0, points to the return value of the

.L regcomp()

call.

If the

.L regcomp()

call fails,

.L regcache()

returns 0 and

.L pcode

will point to the non-zero error code.

Do not call

.L regfree()

on the

.L re

returned by

.LR regcache() .

Both

.L pattern

and

.L flags

are used to match entries in the cache.

When the cache is full the least recently used

.L re

is freed (via

.LR regfree() )

to make space for the new pattern.

Any

.L re

previously returned by

.L regcache()

may be freed (invalidated) on the next call to

.LR regcache() .

If

.L pattern

is longer that 255 bytes then it is still passed on to

.LR regcomp() ,

but it will not be cached.

If

.L pattern

is 0 then the cache is flushed.

In addition, if the integer value of

.L flags

is greater than the current cache size, the cache size is increased

to that integer value.

0 is always returned when

.L pattern

is 0;

.L pcode

will point to a non-zero value on error.

.SH "SEE ALSO"

strmatch(3)