Free regular expression tester software for linux

Language::Basic::Expression is a Perl package to handle string, numeric, and boolean expressions.

SYNOPSIS

See Language::Basic for the overview of how the Language::Basic module works. This pod page is more technical.
# Given an LB::Token::Group, create an expression I parse it
my $exp = new LB::Expression::Arithmetic $token_group;
# Whats the value of the expression?
print $exp->evaluate;
# Perl equivalent of the BASIC expression
print $exp->output_perl;

Expressions are basically the building blocks of Statements, in that every BASIC statement is made up of keywords (like GOTO, TO, STEP) and expressions. So expressions include not just the standard arithmetic and boolean expressions (like 1 + 2), but also lvalues (scalar variables or arrays), functions, and constants. See Language::Basic::Syntax for details on the way expressions are built.

BASIC expressions are represented by various objects of subclasses of Language::Basic::Expression. Most LB::Expressions are in turn made up of other LB::Expressions. For example an LBE::Arithmetic may be made up of two LBE::Multiplicative and a "plus". "Atoms" (indivisible LBEs) include things like LBE::Constants and LBE::Lvalues (variables).

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

regexxer project is a nifty search/replace tool featuring Perl-style regular expressions.

It features recursive search through directory trees and Perl-style regular expressions (using libpcre). The user interface is similar to the project-wide search/replace dialog in the Sniff+ IDE, but regexxer aims to surpass it.

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)

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.