casa  5.7.0-16
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Friends | List of all members
casacore::Regex Class Reference

Regular expression class. More...

#include <Regex.h>

Inheritance diagram for casacore::Regex:
casacore::RegexBase

Public Member Functions

 Regex ()
 Default constructor uses a zero-length regular expression. More...
 
 Regex (const String &exp, Bool fast=False, Int sz=40, const Char *translation=0)
 Construct a regular expression. More...
 
 Regex (const Regex &that)
 Copy constructor (copy semantics). More...
 
virtual ~Regex ()
 
Regexoperator= (const Regex &that)
 Assignment (copy semantics). More...
 
Regexoperator= (const String &strng)
 
const Stringregexp () const
 Get the regular expression string. More...
 
const Chartranstable () const
 Get the translation table (can be a zero pointer). More...
 
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. More...
 
virtual String::size_type search (const Char *s, String::size_type len, Int &matchlen, Int pos=0) const
 Test if the regular expression occurs in string s. More...
 
virtual String::size_type find (const Char *s, String::size_type len, Int &matchlen, String::size_type pos=0) const
 Search string s of length len, starting at position pos. More...
 
Int match_info (Int &start, Int &length, Int nth=0) const
 Return some internal cregex info. More...
 
Bool OK () const
 Does it contain a valid Regex? More...
 
- Public Member Functions inherited from casacore::RegexBase
virtual ~RegexBase ()
 Destructor. More...
 
virtual String::size_type rfind (const Char *s, String::size_type len, Int &matchlen, String::size_type pos=String::npos) const
 Do an rfind() on the string s of length len starting at position pos. More...
 

Static Public Member Functions

static String fromPattern (const String &pattern)
 Convert a shell-like pattern to a regular expression. More...
 
static String fromSQLPattern (const String &pattern)
 Convert an SQL-like pattern to a regular expression. More...
 
static String fromString (const String &strng)
 Convert a normal string to a regular expression. More...
 
static String makeCaseInsensitive (const String &strng)
 Create a case-insensitive reular expression string from the given regular expression string. More...
 

Protected Member Functions

void create (const String &, Int, Int, const Char *)
 Compile the regular expression. More...
 
void dealloc ()
 Deallocate the stuff allocated by create. More...
 

Protected Attributes

String str
 
Int fastval
 
Int bufsz
 
Chartrans
 
re_pattern_bufferbuf
 
re_registersreg
 

Friends

ostream & operator<< (ostream &ios, const Regex &exp)
 Write as ASCII. More...
 

Detailed Description

Regular expression class.

Intended use:

Public interface

Review Status

Reviewed By:
Friso Olnon
Date Reviewed:
1995/03/20
Test programs:
tRegex

Synopsis

This class provides regular expression functionality, such as matching and searching in strings, comparison of expressions, and input/output. It is built on the regular expression functions in the GNU library (see files cregex.h and cregex.cc).
Apart from proper regular expressions, it also supports glob patterns (UNIX file name patterns) by means of a conversion to a proper regex. Also ordinary strings can be converted to a proper regex.

cregex.cc supports many syntaxes. Regex supports only one syntax, the extended regular expression with { and not \{ as a special character. The special characters are:

^
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.
\1 till \9. Backreference to a subexpression. Matches part of string equal to string part that matched the subexpression.

Special characters have to be escaped with a backslash to use them literally. Only inside the square brackets, escaping should not be done. See the man page of egrep or regexp for more information about regular expressions.

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

The static member function fromPattern converts a shell-like pattern to a String which can be used to create a Regex from it. A pattern has the following special characters:

*
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.

The static member function fromSQLPattern converts an SQL-like pattern to a String which can be used to create a Regex from it. A pattern has the following special characters:

%
Zero or more arbitrary characters.
_
One arbitrary character

The static member function fromString converts a normal string to a regular expression. This function escapes characters in the string which are special in a regular expression. In this way a normal string can be passed to a function taking a regular expression.

The static member function makeCaseInsensitive returns a new regular expression string containing the case-insensitive version of the given expression string.

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);

In RXdouble the. is escaped via a backslash to get it literally. The second backslash is needed to escape the backslash in C++.

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

Definition at line 198 of file Regex.h.

Constructor & Destructor Documentation

casacore::Regex::Regex ( )

Default constructor uses a zero-length regular expression.

Thrown Exceptions

  • invalid_argument
casacore::Regex::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
casacore::Regex::Regex ( const Regex that)

Copy constructor (copy semantics).

Thrown Exceptions

  • invalid_argument
virtual casacore::Regex::~Regex ( )
virtual

Member Function Documentation

void casacore::Regex::create ( const String ,
Int  ,
Int  ,
const Char  
)
protected

Compile the regular expression.

Thrown Exceptions

  • invalid_argument
void casacore::Regex::dealloc ( )
protected

Deallocate the stuff allocated by create.

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

Search string s of length len, starting at position pos.

Returned is the address of the first character of the substring found (or String::npos if not found). The matched length is returned in matchlen

Implements casacore::RegexBase.

static String casacore::Regex::fromPattern ( const String pattern)
static

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 casacore::Regex::fromSQLPattern ( const String pattern)
static

Convert an SQL-like pattern to a regular expression.

This is useful TaQL which mimics SQL.

static String casacore::Regex::fromString ( const String strng)
static

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.

static String casacore::Regex::makeCaseInsensitive ( const String strng)
static

Create a case-insensitive reular expression string from the given regular expression string.

It does it by inserting the lowercase and uppercase version of characters in the input string into the output string.

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

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.


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

Reimplemented from casacore::RegexBase.

Int casacore::Regex::match_info ( Int start,
Int length,
Int  nth = 0 
) const

Return some internal cregex info.

Bool casacore::Regex::OK ( ) const

Does it contain a valid Regex?

Regex& casacore::Regex::operator= ( const Regex that)

Assignment (copy semantics).

Thrown Exceptions

  • invalid_argument
Regex& casacore::Regex::operator= ( const String strng)
const String& casacore::Regex::regexp ( ) const
inline

Get the regular expression string.

Definition at line 259 of file Regex.h.

References str.

Referenced by casacore::TaqlRegex::match().

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

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.
Tip: Use the appropriate String functions to test if a regular expression occurs in a string; Regex::search is pretty low-level;

Reimplemented from casacore::RegexBase.

const Char* casacore::Regex::transtable ( ) const
inline

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

Definition at line 263 of file Regex.h.

References trans.

Friends And Related Function Documentation

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

Write as ASCII.

Member Data Documentation

re_pattern_buffer* casacore::Regex::buf
protected

Definition at line 317 of file Regex.h.

Int casacore::Regex::bufsz
protected

Definition at line 315 of file Regex.h.

Int casacore::Regex::fastval
protected

Definition at line 314 of file Regex.h.

re_registers* casacore::Regex::reg
protected

Definition at line 318 of file Regex.h.

String casacore::Regex::str
protected

Definition at line 313 of file Regex.h.

Referenced by regexp().

Char* casacore::Regex::trans
protected

Definition at line 316 of file Regex.h.

Referenced by transtable().


The documentation for this class was generated from the following file: