| Regular expressions for text processing on strings, pattern matching, scanners.
Text processing predicates:
- match/2/3
- match_all/3
- substitute/4
- substitute_all/4
- split/2/3
- chop/2
- get_line/1/2
Regular Expressions:
Regular expressions are sequences of simple characters
and meta characters. All characters which are not
meta characters stand for themselves.
Examples:
a stands for the character "a"
ab stands for the character sequence "ab"
%% stands for the character "%"
meta characters:
| disjunction
(...) bracketed expression
. any single character
^ first position of a string
$ last position of a string
%d digit
%D not a digit
%s white space
%w character of a word (letter or digit or _)
%W not a character of a word
%< start of a word
i.e. current character is %w and previous is not %w
%> end of a word
i.e. current character is not %w and previous is %w
case sensitivity
%i all following characters are case insensitive
%I all following characters are not case sensitive
classes of characters
[...] one of the listed characters
[^...] not one of the listed characters
The character "-" is used within a class to define a range,
e.g. [a-zA-Z0-9_] is the same as %w.
Grouping and lookahead
(?:...) simple grouping (no sideeffects)
(?=...) positive lookahead,
true if ... follows, but ... is not consumed
(?!...) negative lookahead,
true if ... does not follow, nothing is consumed
Quantifier
Quantifiers are given as suffixes.
The following quantifiers are defined:
* any number of
+ at least once
? none or one
{min,max} "min" to "max" times
{min,} at least "min" times
{n} exactly "n" times
Quantifiers are eager, they try to go for the longest
possible matching string.
To find the shortest possible matching string add a "?"
to the quantifier.
Note: to add a backslash into an atom the backslash
must be written twice ("escape of an atom").
Note: to use a percent mark in an expression the percent
mark must be written twice ("escape of the regular expression").
Examples:
match('(%d+)', 'one123four', L) => L = ['123']
match('(.*)a', barbara, L) => L = [barbar]
match('(.*?)a', barbara, L) => L = [b]
match_all('%<(%w+)', ' one two three ', L)
=> L = [one,two,three]
split('one two three', L) => L = [one,two,three]
chop(' one two ', L) => L = 'one two'
split('%s*:%s*', 'one : two :three', L)
=> L = [one,two,three]
substitute_all('a(.)', barbara, '%1a', L).
==> L = brabraa
e.g. to exchange the position of words
substitute('(%w+) (%w+)', 'one two', '%2 %1', L).
==> L = 'two one'
Bracketed Units
Whatever is bracketed is assigned to a term. Whatever is bracketed by
the from left to right i-th opening bracket is assigned to the i-th
term. Bracketed terms can be referenced in substitute/4 and
substitute_all/4 with %1...%9 in the substitute expression.
For match/3 and match_all/3 these are returned in the corresponding
sequence. If a bracketed expression was not evaluated, e.g. because
it appeared in a disjunction, then its result is ''.
Examples:
match_all('((%w+)|(%s+))', 'a few tokens', L).
=> L = [[a,a,''],[' ','',' '],[few,few,''],[' ','',' '],[tokens,tokens,'']]
match_all('%<(%w+)', 'a few tokens', L).
=> L = [[a],[few],[tokens]]
| 
