108 lines
4.2 KiB
Groff
108 lines
4.2 KiB
Groff
|
|
NAME
|
|
regcmp, regex - compile and execute regular expression
|
|
SYNTAX
|
|
char *regcmp (string1 [, string2, ...], (char *)0)
|
|
char *string1, *string2, ...;
|
|
char *regex (re, subject[, ret0, ...])
|
|
char *re, *subject, *ret0, ...;
|
|
extern char *__loc1;
|
|
DESCRIPTION
|
|
Regcmp compiles a regular expression and returns a pointer
|
|
to the compiled form. Malloc(3C) is used to create space
|
|
for the vector. It is the user's responsibility to free
|
|
unneeded space so allocated. A NULL return from regcmp
|
|
indicates an incorrect argument. Regcmp(1) has been written
|
|
to generally preclude the need for this routine at execution
|
|
time.
|
|
Regex executes a compiled pattern against the subject
|
|
string. Additional arguments are passed to receive values
|
|
back. Regex returns NULL on failure or a pointer to the
|
|
next unmatched character on success. A global character
|
|
pointer __loc1 points to where the match began. Regcmp and
|
|
regex were mostly borrowed from the editor, ed(1); however,
|
|
the syntax and semantics have been changed slightly. The
|
|
following are the valid symbols and their associated
|
|
meanings.
|
|
[]*.^ These symbols retain their current meaning.
|
|
$ Matches the end of the string; \n matches a new-
|
|
line.
|
|
- Within brackets the minus means through. For
|
|
example, [a-z] is equivalent to [abcd...xyz]. The
|
|
- can appear as itself only if used as the first
|
|
or last character. For example, the character
|
|
class expression []-] matches the characters
|
|
] and -.
|
|
+ A regular expression followed by + means one or
|
|
more times. For example, [0-9]+ is equivalent to
|
|
[0-9][0-9]*.
|
|
{m} {m,} {m,u}
|
|
Integer values enclosed in {} indicate the number
|
|
of times the preceding regular expression is to be
|
|
applied. The value m is the minimum number and u
|
|
is a number, less than 256, which is the maximum.
|
|
|
|
If only m is present (e.g., {m}), it indicates the
|
|
exact number of times the regular expression is to
|
|
be applied. The value {m,} is analogous to
|
|
{m,infinity}. The plus (+) and star (*)
|
|
operations are equivalent to {1,} and {0,}
|
|
respectively.
|
|
( ... )$n The value of the enclosed regular expression is to
|
|
be returned. The value will be stored in the
|
|
(n+1)th argument following the subject argument.
|
|
At most ten enclosed regular expressions are
|
|
allowed. Regex makes its assignments
|
|
unconditionally.
|
|
( ... ) Parentheses are used for grouping. An operator,
|
|
e.g., *, +, {}, can work on a single character or
|
|
a regular expression enclosed in parentheses. For
|
|
example, (a*(cb+)*)$0.
|
|
By necessity, all the above defined symbols are special.
|
|
They must, therefore, be escaped to be used as themselves.
|
|
EXAMPLES
|
|
Example 1:
|
|
char *cursor, *newcursor, *ptr;
|
|
...
|
|
newcursor = regex((ptr = regcmp("^\n", 0)), cursor);
|
|
free(ptr);
|
|
This example will match a leading new-line in the subject
|
|
string pointed at by cursor.
|
|
Example 2:
|
|
char ret0[9];
|
|
char *newcursor, *name;
|
|
...
|
|
name = regcmp("([A-Za-z][A-za-z0-9_]{0,7})$0", '(char *)0');
|
|
newcursor = regex(name, "123Testing321", ret0);
|
|
This example will match through the string ``Testing3'' and
|
|
will return the address of the character after the last
|
|
matched character (cursor+11). The string ``Testing3'' will
|
|
be copied to the character array ret0.
|
|
Example 3:
|
|
#include "file.i"
|
|
char *string, *newcursor;
|
|
...
|
|
newcursor = regex(name, string);
|
|
This example applies a precompiled regular expression in
|
|
file.i [see regcmp(1)] against string.
|
|
This routine is kept in /lib/<module>/libPW.a, where module
|
|
is either small or large.
|
|
SEE ALSO
|
|
malloc(3C).
|
|
ed(1), regcmp(1) in the UNIX System V User Reference Manual.
|
|
BUGS
|
|
The user program may run out of memory if regcmp is called
|
|
iteratively without freeing the vectors no longer required.
|
|
The following user-supplied replacement for malloc(3C)
|
|
reuses the same vector, saving time and space:
|
|
/* user's program */
|
|
...
|
|
char *
|
|
malloc(n)
|
|
unsigned n;
|
|
{
|
|
static char rebuf[512];
|
|
return (n <= sizeof rebuf) ? rebuf : NULL;
|
|
}
|
|
|