Regular Expressions

This library includes routines to determine whether a regular expression matches part or all of a string. More...

Detailed Description

This library includes routines to determine whether a regular expression matches part or all of a string.

The routines can also return which parts parts of the string matched the expression or subexpressions of it This library relies on Henry Spencer's C-package and is only available in operating systems that support dynamic loading The C-code has been obtained from the sources of FreeBSD-4.0 and is protected by copyright from Henry Spencer and from the Regents of the University of California (see the file library/regex/COPYRIGHT for further details)

Much of the description of regular expressions below is copied verbatim from Henry Spencer's manual page

A regular expression is zero or more branches, separated by `| It matches anything that matches one of the branches

A branch is zero or more pieces, concatenated It matches a match for the first, followed by a match for the second, etc

A piece is an atom possibly followed by \*, +, or ? An atom followed by \* matches a sequence of 0 or more matches of the atom An atom followed by + matches a sequence of 1 or more matches of the atom An atom followed by ? matches a match of the atom, or the null string

An atom is a regular expression in parentheses (matching a match for the regular expression), a range (see below), (matching any single character), ^ (matching the null string at the beginning of the input string), $ (matching the null string at the end of the input string), a \ followed by a single character (matching that character), or a single character with no other significance (matching that character)

A range is a sequence of characters enclosed in [] It normally matches any single character from the sequence If the sequence begins with ^, it matches any single character not from the rest of the sequence If two characters in the sequence are separated by -, this is shorthand for the full list of ASCII characters between them (e.g [0-9] matches any decimal digit) To include a literal ] in the sequence, make it the first character (following a possible ^) To include a literal -, make it the first or last character

---

Class Documentation

regexp/3

class regexp/3

regexp(+ RegExp,+ String,+ Opts)

Match regular expression RegExp to input string String according to options Opts The options may be:

• nocase: Causes upper-case characters in String to be treated as lower case during the matching process

regexp/4

class regexp/4

regexp(+ RegExp,+ String,+ Opts,? SubMatchVars)

Match regular expression RegExp to input string String according to options Opts The variable SubMatchVars should be originally unbound or a list of unbound variables all will contain a sequence of matches, that is, the head of SubMatchVars will contain the characters in String that matched the leftmost parenthesized subexpression within RegExp, the next head of list will contain the characters that matched the next parenthesized subexpression to the right in RegExp, and so on

The options may be:

• nocase: Causes upper-case characters in String to be treated as lower case during the matching process
• indices: Changes what is stored in SubMatchVars Instead of storing the matching characters from String, each variable will contain a term of the form IO-IF giving the indices in String of the first and last characters in the matching range of characters

In general there may be more than one way to match a regular expression to an input string For example, consider the command

regexp("(a*)b*","aabaaabb", [], [X,Y])

Considering only the rules given so far, X and Y could end up with the values "aabb" and "aa", "aaab" and "aaa", "ab" and "a", or any of several other combinations To resolve this potential ambiguity regexp chooses among alternatives using the rule first then longest In other words, it considers the possible matches in order working from left to right across the input string and the pattern, and it attempts to match longer pieces of the input string before shorter ones More specifically, the following rules apply in decreasing order of priority:

• If a regular expression could match two different parts of an input string then it will match the one that begins earliest
• If a regular expression contains "|" operators then the leftmost matching sub-expression is chosen
• In *, +, and ? constructs, longer matches are chosen in preference to shorter ones
• In sequences of expression components the components are considered from left to right

In the example above, "(a\*)b\*" matches "aab": the "(a\*)" portion of the pattern is matched first and it consumes the leading "aa"; then the "b\*" portion of the pattern consumes the next "b" Or, consider the following example:

regexp("(ab|a)(b*)c",  "abc", [], [X,Y,Z])

After this command X will be "abc", Y will be "ab", and Z will be an empty string Rule 4 specifies that "(ab|a)" gets first shot at the input string and Rule 2 specifies that the "ab" sub-expression is checked before the "a" sub-expression Thus the "b" has already been claimed before the "(b\*)" component is checked and (b\*) must match an empty string