Free regular expressions software for linux

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.

RegExplorer project is a regular Expression Explorer.

It allows for writing regular expressions and visually see the matches, thus making regular expression much easier to write and maintain.

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

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

Regexp::Wildcards is a Perl module that converts wildcard expressions to Perl regular expressions.

SYNOPSIS

use Regexp::Wildcards qw/wc2re/;

my $re;
$re = wc2re a{b?,c}* => unix; # Do it Unix style.
$re = wc2re a?,b* => win32; # Do it Windows style.
$re = wc2re *{x,y}? => jokers; # Process the jokers & escape the rest.
$re = wc2re %a_c% => sql; # Turn SQL wildcards into regexps.

In many situations, users may want to specify patterns to match but dont need the full power of regexps. Wildcards make one of those sets of simplified rules. This module converts wildcard expressions to Perl regular expressions, so that you can use them for matching. It handles the * and ? shell jokers, as well as Unix bracketed alternatives {,}, but also % and _ SQL wildcards. Backspace () is used as an escape character. Wrappers are provided to mimic the behaviour of Windows and Unix shells.

VARIABLES

These variables control if the wildcards jokers and brackets must capture their match. They can be globally set by writing in your program

$Regexp::Wildcards::CaptureSingle = 1;
# From then, "exactly one" wildcards are capturing
or can be locally specified via local
{
local $Regexp::Wildcards::CaptureSingle = 1;
# In this block, "exactly one" wildcards are capturing.
...
}
# Back to the situation from before the block

This section describes also how those elements are translated by the functions.
$CaptureSingle

When this variable is true, each occurence of unescaped "exactly one" wildcards (i.e. ? jokers or _ for SQL wildcards) are made capturing in the resulting regexp (they are be replaced by (.)). Otherwise, they are just replaced by .. Default is the latter.

For jokers :
a???b?? is translated to a(.)(.)(.)b?(.) if $CaptureSingle is true
a...b?. otherwise (default)

For SQL wildcards :
a___b__ is translated to a(.)(.)(.)b_(.) if $CaptureSingle is true
a...b_. otherwise (default)
$CaptureAny

By default this variable is false, and successions of unescaped "any" wildcards (i.e. * jokers or % for SQL wildcards) are replaced by one single .*. When it evalutes to true, those sequences of "any" wildcards are made into one capture, which is greedy ((.*)) for $CaptureAny > 0 and otherwise non-greedy ((.*?)).

For jokers :
a***b** is translated to a.*b*.* if $CaptureAny is false (default)
a(.*)b*(.*) if $CaptureAny > 0
a(.*?)b*(.*?) otherwise

For SQL wildcards :
a%%%b%% is translated to a.*b%.* if $CaptureAny is false (default)
a(.*)b%(.*) if $CaptureAny > 0
a(.*?)b%(.*?) otherwise
$CaptureBrackets

If this variable is set to true, valid brackets constructs are made into ( | ) captures, and otherwise they are replaced by non-capturing alternations ((?: | )), which is the default.

a{b},{c} is translated to a(b}|{c) if $CaptureBrackets is true
a(?:b}|{c) otherwise (default)

GNUMail.app is a fully featured mail application running on Linux (or FreeBSD, OpenBSD, etc) and Apple Mac OS X.
GNUMail.app uses the GNUstep development framework or Apple Cocoa, which is based on the OpenStep specification provided by NeXT, Inc.. GNUMail.app is licensed under the GPL, and the full sources of the application are available.
GNUMail.app was written from scratch. It uses Pantomime as its mail handling framework.
Main features:
- Multiple POP3 (with APOP support) accounts with local cache support (for leaving messages on server);
- Multiple delivery agents (SMTP or local mailer);
- Mail spool file support for receiving;
- Good IMAP support with local caching;
- Full RFC822 and RFC2822 support;
- Read, compose, bounce, reply and forward mails;
- Mailbox management (create, delete, locking and transfer messages) using the Berkeley mbox format;
- Personal preferences management;
- MIME support (decode and encode);
- A full MIME types manager;
- Quoted Printable and BASE64 support;
- Address Book with groups support;
- Find Panel with regular expressions support;
- Automatic or manual fetching of your mails (users choice);
- Powerful filters that supports regular expressions;
- GPG (PGP) support through a bundle;
- Messages threading;
- And more...

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.