Regex.h

Classes

Regex -- Regular expression class (full description)

class Regex : public RegexBase

Interface

Public Members

Regex()

Regex(const String &exp, Bool fast = False, Int sz = 40, const Char *translation = 0)

Regex(const Regex &that)

virtual ~Regex()

Regex &operator=(const Regex &that)

Regex &operator=(const String &strng)

static String fromPattern(const String &pattern)

static String fromSQLPattern(const String &pattern)

static String fromString(const String &strng)

const String &regexp() const

const Char *transtable() const

virtual String::size_type match(const Char *s, String::size_type len, String::size_type pos=0) const

virtual String::size_type search(const Char *s, String::size_type len, Int &matchlen, Int pos=0) const

virtual String::size_type find(const Char *s, String::size_type len, Int &matchlen, String::size_type pos=0) const

Int match_info(Int& start, Int& length, Int nth = 0) const

Bool OK() const

friend ostream &operator<<(ostream &ios, const Regex &exp)

Protected Members

void create(const String&, Int, Int, const Char*)

void dealloc()

Description

Review Status

Reviewed By:

Friso Olnon

Date Reviewed:

1995/03/20

Programs:

Tests:

• tRegex

Synopsis

^

matches the beginning of a line.

$

matches the end of a line.

.

matches any character

*

zero or more times the previous subexpression.

+

one or more times the previous subexpression.

?

zero or one time the previous subexpression.

{n,m}

interval operator to specify how many times a subexpression can match. See man page of egrep or regexp for more detail.

[]

matches any character inside the brackets; e.g. [abc]. A hyphen can be used for a character range; e.g. [a-z].
A ^ right after the opening bracket indicates "not"; e.g. [^abc] means any character but a, b, and c. If ^ is not the first character, it is a literal caret. If - is the last character, it is a literal hyphen. If ] is the first character, it is a literal closing bracket.
Special character classes are [:alpha:], [:upper:], [:lower:], [:digit:], [:alnum:], [:xdigit:], [:space:], [:print:], [:punct:], [:graph:], and [:cntrl:]. The brackets are part of the name; e.g. [^[:upper:]] is equal to [^A-Z]. Note that [:upper:] is more portable, because A-Z fails for the EBCDIC character set.

( )

grouping to change the normal operator precedence.

|

or operator. Matches left side or right side.

Several global Regex objects are predefined for common functionality.

RXwhite

one or more whitespace characters

RXint

integer number (also negative)

RXdouble

double number (with e or E as exponent)

RXalpha

one or more alphabetic characters (lowercase and/or uppercase)

RXlowercase

lowercase alphabetic

RXuppercase

uppercase alphabetic

RXalphanum

one or more alphabetic/numeric characters (lowercase and/or uppercase)

RXidentifier

identifier name (first alphabetic or underscore, then zero or more alphanumeric and/or underscores

*

Zero or more arbitrary characters.

?

One arbitrary character

[]

The same as [] in a regular expression (see above). In addition to ^ a ! can be used to indicate "not".

{,}

A brace expression which is like brace expansion in some shells. It is similar to the | construct in a regular expression.
E.g. {abc,defg} means abc or defg. Brace expressions can be nested and can contain other special characters.
E.g. St{Man*.{h,cc},Col?*.{h,cc,l,y}}
A literal comma or brace in a brace expression can be given by escaping it with a backslash.

%

Zero or more arbitrary characters.

_

One arbitrary character

Example

    Regex RXwhite("[ \n\t\r\v\f]+", 1);
           (blank, newline, tab, return, vertical tab, formfeed)
    Regex RXint("-?[0-9]+", 1);
    Regex RXdouble("-?(([0-9]+\\.[0-9]*)|([0-9]+)|(\\.[0-9]+))([eE][+-]?[0-9]+)?", 1, 200);
    Regex RXalpha("[A-Za-z]+", 1);
    Regex RXlowercase("[a-z]+", 1);
    Regex RXuppercase("[A-Z]+", 1);
    Regex RXalphanum("[0-9A-Za-z]+", 1);
    Regex RXidentifier("[A-Za-z_][A-Za-z0-9_]*", 1);
    

    Regex rx1 (Regex::fromPattern ("St*.{h,cc}");
               results in regexp "St.*\.((h)|(cc))"
    Regex rx2 (Regex::fromString ("tRegex.cc");
               results in regexp "tRegex\.cc"
    

To Do

• Let sgi ifdef go
• Decide on documentation of GNU stuff (cregex.h, cregex.cc)

Member Description

Regex()

Thrown Exceptions

• invalid_argument

Regex(const String &exp, Bool fast = False, Int sz = 40, const Char *translation = 0)

Construct a regular expression. Optionally a fast map can be created, a buffer size can be given and a translation table (of 256 chars) can be applied. The translation table can, for instance, be used to map lowercase characters to uppercase. See cregex.cc (the extended regular expression matching and search library) for detailed information.

Thrown Exceptions

• invalid_argument

Regex(const Regex &that)

Copy constructor (copy semantics).

Thrown Exceptions

• invalid_argument

virtual ~Regex()

Regex &operator=(const Regex &that)
Regex &operator=(const String &strng)

Assignment (copy semantics).

Thrown Exceptions

• invalid_argument

static String fromPattern(const String &pattern)

Convert a shell-like pattern to a regular expression. This is useful for people who are more familiar with patterns than with regular expressions.

static String fromSQLPattern(const String &pattern)

Convert an SQL-like pattern to a regular expression. This is useful TaQL which mimics SQL.

static String fromString(const String &strng)

Convert a normal string to a regular expression. This consists of escaping the special characters. This is useful when one wants to provide a normal string (which may contain special characters) to a function working on regular expressions.

const String &regexp() const

Get the regular expression string.

const Char *transtable() const

Get the translation table (can be a zero pointer).

virtual String::size_type match(const Char *s, String::size_type len, String::size_type pos=0) const

Test if the regular expression matches (part of) string s. The return value gives the length of the matching string part, or String::npos if there is no match or an error. The string has len characters and the test starts at position pos. The string may contain null characters. Negative p is allowed to match at end.

Use the appropriate String functions to test if a string matches a regular expression. Regex::match is pretty low-level.

virtual String::size_type search(const Char *s, String::size_type len, Int &matchlen, Int pos=0) const
virtual String::size_type find(const Char *s, String::size_type len, Int &matchlen, String::size_type pos=0) const

Test if the regular expression occurs in string s. The return value gives the position of the first substring matching the regular expression. The length of that substring is returned in matchlen. The string has len characters and the test starts at position pos. The string may contain null characters. The search will do a reverse search if the pos given is less than 0.

Use the appropriate String functions to test if a regular expression occurs in a string. Regex::search is pretty low-level.

Int match_info(Int& start, Int& length, Int nth = 0) const

Return some internal cregex info.

Bool OK() const

Does it contain a valid Regex?

friend ostream &operator<<(ostream &ios, const Regex &exp)

Write as ASCII.

void create(const String&, Int, Int, const Char*)

Compile the regular expression

Thrown Exceptions

• invalid_argument

void dealloc()

Deallocate the stuff allocated by create.