Free regular software for linux

regular expression parser is a C++ regexp parser that accomplishes The Open Group specification Issue 6, IEEE Std 1003.1, 2004 Edition.

regular expression parser allows you to parse input using regular expressions, and to retrieve parsed sub-expression matches in a few steps.

Regular Expression Graphing Program project is a regular expression graphing program.
This program is designed to take a regular expression and produce a graph of the state machine that is used to parse the regular expression.
It is useful for teaching regular expressions and state machines.
The program comes with a built-in tutorial and sample set of regular expressions.
Main features:
- This will not graph all the regular expressions. Some of the more advanced features of the engine are just not handled.
- We currently ``graph the ``group, no $1 (?:..) operator by displaying nothing. A box should be put around the expression.
- The boxes drawn by the program are a fixed with not related to the size of the text they contain. Text can easily overflow the box.
- The system is UNIX/Linux specific. This is caused by only one small section of code should anyone want to port this to a braindamaged operating system.
- Better use of color can be made. Specifically all the nodes do not have to be green. Come to think of it they call dont have to be rectangles either.
- Sometimes the lines connecting one section to another take some strange twists.

RegURL is an extension which applies a regular expression on the URL.

A regular expression is a string that is used to describe or match a set of strings, according to certain syntax rules. For example, the regular expression bex can be used to describe (and search for) all of the instances of the string "ex" that occur at word breaks (signified by the b).

Thus in the phrase, "Texts for expert experimenters," the regular expresssion bex returns the "ex" in "expert" and "experimenters," but not in "Texts" (because the "ex" occurs inside the word there and not at the word break).

Regular expressions are used by many text editors and utilities to search and manipulate bodies of text based on certain patterns. Many programming languages support regular expressions for string manipulation.

For example, Perl and Tcl have a powerful regular expression engine built directly into their syntax. The set of utilities (including the editor ed and the filter grep) provided by Unix distributions were the first to popularize the concept of regular expressions.

"Regular expression" is often shortened in speech to regex, and in writing to regexp or regex (singular) or regexps, regexes, or regexen (plural).

glark offers grep-like searching of text files, with very powerful, complex regular expressions (e.g., "/foow+/ and /bar[^d]*baz$/ within 4 lines of each other").

glark offers: Perl compatible regular expressions, highlighting of matches, context around matches, complex expressions (``and and ``or), and automatic exclusion of non-text files.

GRegExp Explorer is a graphical regular expression explorer based on the PCRE regular expression library. It is possible to test regular expressions on the fly and check the result in detail.

Regexx is a complete regular expressions C++ solution.

Regexx implements easy expression execution, global searching, replace with atom substitution, customized replaces, easy match/atom string retrieving, and splitting strings with strings or regular expressions.

Regexp::Assemble is Perl module to assemble multiple Regular Expressions into a single RE.

SYNOPSIS

use Regexp::Assemble;

my $ra = Regexp::Assemble->new;
$ra->add( ab+c );
$ra->add( ab+- );
$ra->add( awd+ );
$ra->add( ad+ );
print $ra->re; # prints a(?:w?d+|b+[-c])

Regexp::Assemble takes an arbitrary number of regular expressions and assembles them into a single regular expression (or RE) that matches all that the individual REs match.

As a result, instead of having a large list of expressions to loop over, a target string only needs to be tested against one expression. This is interesting when you have several thousand patterns to deal with. Serious effort is made to produce the smallest pattern possible.

It is also possible to track the original patterns, so that you can determine which, among the source patterns that form the assembled pattern, was the one that caused the match to occur.

You should realise that large numbers of alternations are processed in perls regular expression engine in O(n) time, not O(1). If you are still having performance problems, you should look at using a trie. Note that Perls own regular expression engine will implement trie optimisations in perl 5.10 (they are already available in perl 5.9.3 if you want to try them out). Regexp::Assemble will do the right thing when it knows its running on a a tried perl. (At least in some version after this one).

perlrecharclass package contains Perl regular expression character classes.

The top level documentation about Perl regular expressions is found in perlre.
This manual page discusses the syntax and use of character classes in Perl Regular Expressions.

A character class is a way of denoting a set of characters, in such a way that one character of the set is matched. Its important to remember that matching a character class consumes exactly one character in the source string. (The source string is the string the regular expression is matched against.)
There are three types of character classes in Perl regular expressions: the dot, backslashed sequences, and the bracketed form.

The dot

The dot (or period), . is probably the most used, and certainly the most well-known character class. By default, a dot matches any character, except for the newline. The default can be changed to add matching the newline with the single line modifier: either for the entire regular expression using the /s modifier, or locally using (?s).

Here are some examples:

"a" =~ /./ # Match
"." =~ /./ # Match
"" =~ /./ # No match (dot has to match a character)
"n" =~ /./ # No match (dot does not match a newline)
"n" =~ /./s # Match (global single line modifier)
"n" =~ /(?s:.)/ # Match (local single line modifier)
"ab" =~ /^.$/ # No match (dot matches one character)

Backslashed sequences

Perl regular expressions contain many backslashed sequences that constitute a character class. That is, they will match a single character, if that character belongs to a specific set of characters (defined by the sequence). A backslashed sequence is a sequence of characters starting with a backslash. Not all backslashed sequences are character class; for a full list, see perlrebackslash.

Heres a list of the backslashed sequences, which are discussed in more detail below.

d Match a digit character.
D Match a non-digit character.
w Match a "word" character.
W Match a non-"word" character.
s Match a white space character.
S Match a non-white space character.
h Match a horizontal white space character.
H Match a character that isnt horizontal white space.
v Match a vertical white space character.
V Match a character that isnt vertical white space.
pP, p{Prop} Match a character matching a Unicode property.
PP, P{Prop} Match a character that doesnt match a Unicode property.