RWCRExpr (deprecated)

Module:  Essential Tools Module   Group:  String Processing Classes

Does not inherit

• Local Index
• Synopsis
• Deprecation Notice
• Description
• Persistence
• Example
• Public Constructors
• Public Destructor
• Assignment Operators
• Public Member Functions

Members

index() operator=()

RWCRExpr() status()

~RWCRExpr()

#include <rw/re.h>
RWCRExpr re(".*\\.doc$");  // Matches filename with suffix ".doc"

This alternative interface is now deprecated and may be eliminated from a later release. For more information on the support of deprecated classes, please contact your Rogue Wave account representative

Use the RWTRegex<T> interface instead of this class. RWTRegex<T> provides enhanced functionality and increased performance.

Class RWCRExpr represents an extended regular expression such as those found in lex and awk. The constructor "compiles" the expression into a form that can be used more efficiently. The results can then be used for string searches using class RWCString. Regular expressions can be of arbitrary size, limited by memory. The extended regular expression features found here are a subset of those found in the POSIX.2 standard (ANSI/IEEE Std 1003.2, ISO/IEC 9945-2).

Note: RWCRExpr is available only if your compiler supports exception handling and the C++ Standard Library.

The regular expression (RE) is constructed as follows:

The following rules determine one-character REs that match a single character:

Any character that is not a special character (to be defined) matches itself.

1. A backslash (\) followed by any special character matches the literal character itself; that is, this escapes the special character.

2. The "special characters" are:

   +   *   ?   .   [   ]   ^   $   (   )   {   }   |   \ 

3. The period (.) matches any character. For example, ".umpty" matches either "Humpty" or "Dumpty."

4. A set of characters enclosed in brackets ([ ]) is a one-character RE that matches any of the characters in that set. This means that [akm] matches either an "a", "k", or "m". A range of characters can be indicated with a dash, as in [a-z], which matches any lower-case letter. However, if the first character of the set is the caret (^), then the RE matches any character except those in the set. It does not match the empty string. For example: [^akm] matches any character except "a", "k", or "m". The caret loses its special meaning if it is not the first character of the set.

The following rules can be used to build a multicharacter RE:

1. Parentheses (( )) group parts of regular expressions together into subexpressions that can be treated as a single unit. For example, (ha)+ matches one or more "had's.

2. A one-character RE followed by an asterisk (*) matches zero or more occurrences of the RE. Hence, [a-z]* matches zero or more lower-case characters.

3. A one-character RE followed by a plus (+) matches one or more occurrences of the RE. Hence, [a-z]+ matches one or more lower-case characters.

4. A question mark (?) is an optional element. The preceding RE can occur zero or once in the string -- no more. For example, xy?z matches either xyz or xz.

5. The concatenation of REs is a RE that matches the corresponding concatenation of strings. For example, [A-Z][a-z]* matches any capitalized word.

6. The OR character ( | ) allows a choice between two regular expressions. For example, jell(y|ies) matches either "jelly" or "jellies".

7. Braces ({ }) are reserved for future use.

All or part of the regular expression can be "anchored" to either the beginning or end of the string being searched:

1. If the caret (^) is at the beginning of the (sub)expression, then the matched string must be at the beginning of the string being searched.

2. If the dollar sign ($) is at the end of the (sub)expression, then the matched string must be at the end of the string being searched.

The most frequent problem with use of this class is in being able to specify a backslash character to be parsed. If you are attempting to parse a regular expression that contains backslashes, you must be aware that the C++ compiler and the regular expression constructor will both assume that any backslashes they see are intended to escape the following character. Thus, to specify a regular expression that exactly matches "a\a", you would have to create the regular expression using four backslashes as follows: the regular expression needs to see "a\\a", and for that to happen, the compiler would have to see "a\\\\a".

     RWCRExpr reg("a\\\\a");
                    ^|^|
                     1 2

The backslashes marked with a ^ are an escape for the compiler, and the ones marked with | will thus be seen by the regular expression parser. At that point, the backslash marked 1 is an escape, and the one marked 2 will actually be put into the regular expression.

Similarly, if you really need to escape a character, such as a ".", you will have to pass two backslashes to the compiler:

    RWCRExpr regDot("\\.")
                     ^|

Once again, the backslash marked ^ is an escape for the compiler, and the one marked with | will be seen by the regular expression constructor as an escape for the following ".".

None

#include <iostream>
#include <rw/re.h>
#include <rw/cstring.h>

int main ()
{
    RWCString s ("Hark! Hark! the lark");


    std::cout << "Searching for an expression beginning with \"l\" in \"" 
              << s << "\".\n";

    // A regular expression matching any lower-case word
    // starting with 'l':
    RWCRExpr reg("l[a-z]*");

    // Prints 'lark'
    std::cout << "Found \"" << s.match(reg) << "\"." << std::endl; 

    return 0;
}

Program output:

Searching for an expression beginning with "l" in "Hark! Hark! the lark".
Found "lark".

RWCRExpr(const char* pat);
RWCRExpr(const RWCString& pat);

Construct a regular expression from the pattern given by pat. The status of the results can be found by using member function status().

RWCRExpr(const RWCRExpr& r);

Copy constructor. Uses value semantics -- self will be a copy of r.

RWCRExpr();

Default constructor. You must assign a pattern to the regular expression before you use it.

~RWCRExpr();

Destructor. Releases any allocated memory.

RWCRExpr&
operator=(const RWCRExpr& r);

Recompiles self to pattern found in r.

RWCRExpr&
operator=(const char* pat);
RWCRExpr&
operator=(const RWCString& pat);

Recompiles self to the pattern given by pat. The status of the results can be found by using member function status().

size_t
index(const RWCString& str, size_t* len = NULL, 
      size_t start=0) const;

Returns the index of the first instance in the string str that matches the regular expression compiled in self, or RW_NPOS if there is no such match. The search starts at index start. The length of the matching pattern is returned in the variable pointed to by len. If an invalid regular expression is used for the search, an exception of type RWInternalErr will be thrown. Note that this member function is relatively clumsy to use -- class RWCString offers a better interface to regular expression searches.

statusType
status() const;

Returns the status of the regular expression:

Table 15: RWCRExpr statusType Values

statusType	Meaning
RWCRExpr::OK	No errors
RWCRExpr::NOT_SUPPORTED	POSIX.2 feature not yet supported.
RWCRExpr::NO_MATCH	Tried to find a match but failed
RWCRExpr::BAD_PATTERN	Pattern was illegal
RWCRExpr::BAD_COLLATING_ELEMENT	Invalid collating element referenced
RWCRExpr::BAD_CHAR_CLASS_TYPE	Invalid character class type referenced
RWCRExpr::TRAILING_BACKSLASH	Trailing \ in pattern
RWCRExpr::UNMATCHED_BRACKET	[] imbalance
RWCRExpr::UNMATCHED_PARENTHESIS	() imbalance
RWCRExpr::UNMATCHED_BRACE	{} imbalance
RWCRExpr::BAD_BRACE	Content of {} invalid.
RWCRExpr::BAD_CHAR_RANGE	Invalid endpoint in [a-z] expression
RWCRExpr::OUT_OF_MEMORY	Out of memory
RWCRExpr::BAD_REPEAT	?,* or + not preceded by valid regular expression

© Copyright Rogue Wave Software, Inc. All Rights Reserved.
Rogue Wave and SourcePro are registered trademarks of Rogue Wave Software, Inc. in the United States and other countries. All other trademarks are the property of their respective owners.
Contact Rogue Wave about documentation or support issues.