In GNU, you can both match and search for a given regular expression. To do either, you must first compile it in a pattern buffer (see section GNU Pattern Buffers).
Regular expressions match according to the syntax with which they were
compiled; with GNU, you indicate what syntax you want by setting
the variable re_syntax_options
(declared in `regex.h' and
defined in `regex.c') before calling the compiling function,
re_compile_pattern
(see below). See section Syntax Bits, and
section Predefined Syntaxes.
You can change the value of re_syntax_options
at any time.
Usually, however, you set its value once and then never change it.
re_compile_pattern
takes a pattern buffer as an argument. You
must initialize the following fields:
translate initialization
translate
fastmap
buffer
allocated
re_compile_pattern
to allocate memory for the
compiled pattern, set both of these to zero. If you have an existing
block of memory (allocated with malloc
) you want Regex to use,
set buffer
to its address and allocated
to its size (in
bytes).
re_compile_pattern
uses realloc
to extend the space for
the compiled pattern as necessary.
To compile a pattern buffer, use:
char * re_compile_pattern (const char *regex, const int regex_size, struct re_pattern_buffer *pattern_buffer)
regex is the regular expression's address, regex_size is its length, and pattern_buffer is the pattern buffer's address.
If re_compile_pattern
successfully compiles the regular
expression, it returns zero and sets *pattern_buffer
to the
compiled pattern. It sets the pattern buffer's fields as follows:
buffer
used
buffer
occupies.
syntax
re_syntax_options
.
re_nsub
fastmap_accurate
buffer
; in that case (since
you can't make a fastmap without a compiled pattern),
fastmap
would either contain an incompatible fastmap, or nothing
at all.
If re_compile_pattern
can't compile regex, it returns an
error string corresponding to one of the errors listed in section POSIX Regular Expression Compiling.
Go to the first, previous, next, last section, table of contents.