Free regexp tester software for linux

JRegexpTester is a standalone Swing application that helps you test regular expressions with the Sun Java standard API (java.util.regex).
The extracted data can be modified with formatters similar to those used by sprintf, or with standard Java date and decimal formatters. JRegexpTester features RegExLib library integration with more than 900 patterns.
Since the release 0.3, JRegexpTester helps you manage CSV (comma-separated values) files.
Main features:
- easy to use interface.
- immediate response.
- large file extraction permitted (line by line).
- automatic integration of the entire RegExLib.com library (more than 900 patterns ready to use except those .Net specific).
- save/load/export(text,html)./search
- users can easily see all the groups capturing text moving the cursor into the pane of details.
- the open-close brackets (curly and square) and parenthesis are clearly highlighted into the regexp text area.
- easy CSV file management (extract/transform). JRegexpTester can help you manage files with more than 65536 rows which cant be read entirely by Gnumeric.
Enhancements:
- integration of the new webservices of RegexLib V2 into the panel of preferences

Regexp::Parser is a Perl module for parsing regexes.

This module parses regular expressions (regexes). Its default "grammar" is Perl 5.8.4s regex set. Grammar is quoted because the module does not so much define a grammar as let each matched node state what it expects to match next, but there is not currently a way of extracting a complete grammar. This may change in future versions.

This module is designed as a replacement (though not drop-in) for my old YAPE::Regex modules.

USAGE:

Creating an Instance

To use this module as is, load it, and create an instance:

use Regexp::Parser;
my $parser = Regexp::Parser->new;

Setting a Regex

To have the parser work on a specific regex, you can do use any of the following methods:

$parser = Regexp::Parser->new($regex)

You can send the regex to be parsed as the argument to the constructor.

$parser->regex($regex)

Clears the parsers memory and sets $regex as the regex to be parsed.

These two approaches do an initial pass over the regex to make sure it is well-formed -- any warnings or errors will be determined during this initial pass.

Regexp::Genex - get the strings a regex will match, with a regex.

SYNPOSIS

# first try:
$ perl -MRegexp::Genex=:all -le print for strings(qr/a(b|c)d{2,3}e*/)

$ perl -x `pmpath Regexp::Genex`
#!/usr/bin/perl -l

use Regexp::Genex qw(:all);

$regex = shift || "a(b|c)d{2,4}?";

print "Trying: $regex";
print for strings($regex);
# abdd
# abddd
# abdddd
# acdd
# acddd
# acdddd


print "nThe regex code for that was:nqr/";
print strings_rx($regex);
print "/xn";

my $generator = generator($regex);
print "Taking first two using generator";
print $generator->() for 1..2;

my $big_rx = b*?c*?d*?; # * becomes {0,20}

my $big = generator($big_rx, ($max_length = 100) );

print "Taking string 100 of $big_rx";
print $big->(100); # (caveats below)
# ccccdddddddddddddddd NOT dx100 as you may expect

Regexp::Log is a Perl base class for log files regexp builders.

SYNOPSIS

my $foo = Regexp::Log::Foo->new(
format => custom %a %b %c/%d,
capture => [qw( host code )],
);

# the format() and capture() methods can be used to set or get
$foo->format(custom %g %e %a %w/%s %c);
$foo->capture(qw( host code ));

# this is necessary to know in which order
# we will receive the captured fields from the regexp
my @fields = $foo->capture;

# the all-powerful capturing regexp :-)
my $re = $foo->regexp;

while () {
my %data;
@data{@fields} = /$re/; # no need for /o, its a compiled regexp

# now munge the fields
...
}

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::MatchContext is Perl module to replace (and improve) $MATCH, $PREMATCH, and $POSTMATCH

SYNOPSIS

use Regexp::MatchContext -vars;

$str = m/(?p) d+ /;

print "Before: $PREMATCHn";
print "Matched: $MATCHn";
print "After: $POSTMATCHn";

$MATCH = 2 * $MATCH; # substitute into original $str

The English.pm module provides named aliases for Perls built-in $`, $& and $ variables: $PREMATCH, $MATCH, and $POSTMATCH. Unfortunately, those aliases suffer the same problems as their originals: they degrade the performance of every single regex in your program, even if youre only using them to get information about a single match.

This module also provides $PREMATCH, $MATCH, and $POSTMATCH, but in a way that only impacts the performance of matches that you specify. That is, these three variables are only set if the most recently matched regex contained the special (non-standard) meta- flag: (?p).

That is:

use Regexp::MatchContext -vars;

$str = foobarbaz;

$str =~ /(?p) foo /x;

# $PREMATCH contains foo
# $MATCH contains bar
# $POSTMATCH contains baz

$str =~ / foo /x;

# $PREMATCH, $MATCH, and $POSTMATCH all undef

The (?p) marker can be placed anywhere within the regex and, except for setting the three context variables on a successful match, is otherwise totally ignored.

Regexp::Parser::Handlers is a Perl module with handlers for Perl 5 regexes.

This module holds the init() method for the Regexp::Parser class, which installs all the handlers for standard Perl 5 regexes. This documentation contains a sub-classing tutorial.

SUB-CLASSING

I will present two example sub-classes, Regexp::NoCode, and Regexp::AndBranch.

Parser Internals

The parser object is a hash reference with the following keys:

regex

A reference to the original string representation of the regex.

len

The length of the original string representation of the regex.

tree

During the first pass, tree is undef, which instructs the object() method not to actually create any objects. Afterwards, it is an array reference of (node) objects.

stack

Initially an array reference, used to store the tree as a new scope is entered and then exited. The general concept is:

if (into_scope) {
push STACK, TREE;
TREE = CURRENT->DATA;
}
if (outof_scope) {
TREE = pop STACK;
}

After the tree has been created, this key is deleted; this gives the code a way to be sure compilation was successful.

maxpar

The highest number of parentheses. It will end up being identical to nparen, but it is incremented during the initial pass, so that on the second pass (the tree-building), it can distinguish back-references from octal escapes. (The source code to Perls regex compiler does the same thing.)

nparen

The number of OPENs (capturing groups) in the regex.

captures

An array reference to the open nodes.

flags

An array reference of flag values. When a scope is entered, the top value is copied and pushed onto the stack. When a scope is left, the top value is popped and discarded.

It is important to do this copy-and-push before you do any flag-parsing, if youre adding a handle that might parse flags, because you do not want to accidentally affect the previous scopes flag values.

Here is example code from the handler for (?ismx) and (?ismx:...):

# (?i:...) {next} }, qw< c) atom >;
}

for (split //, $on) {
if (my $h = $S->can("FLAG_$_")) {
my $v = $h->(1); # 1 means this is on
if ($v) { &Rf |= $v } # turn the flag on
else { ... } # the flags value is 0
next;
}
# throw an error if the flag isnt supported
}

for (map "FLAG_$_", split //, $off) {
if (my $h = $S->can("FLAG_$_")) {
my $v = $h->(0); # 0 means this is off
if ($v) { &Rf &= ~$v } # turn the flag off
else { ... } # the flags value is 0
next;
}
# throw an error if the flag isnt supported
}

Youll probably not be adding handlers that have to parse flags, but if you do, remember to follow this model correctly.

next

An array reference of what handles (or "rules") to try to match next.

Sub::Regex is a Perl module to create synonymous subroutines.

SYNOPSIS

use Sub::Regex;
sub /look(s|ing)?_for/ ($){
foobar blah blah
}

look_for(Amanda);
looks_for(Amanda);
looking_for(Amanda);
lOoKiNg_fOr(Amanda);

Sub::Regex is a small tool for users to create a subroutine with multiple names. The only thing to be done is replace the normal name of a subroutine with a regular expression. However, regexp modifiers are not allowed, and matching is all considered case-insensitive.