Free regexp reference software for linux

Regexp::Extended is a Perl wrapper that extends the re module with new features.

SYNOPSIS

use Regexp::Extended qw(:all);

# (?...): named parameters
$date =~ /(? d+)-(? d+)-(? d+)/;
if ("2002-10-30" =~ /$date/) {
print "The date is : $::year->[0]-$::month->[0]-$::day->[0]n";
}

# You can also access individial matches in ()* or ()+
"1234" =~ /(? d)+/;
print "Digit 1 is : $::digit->[0]n";
print "Digit 2 is : $::digit->[1]n";
...

# You can also modify individual matches
"1234" =~ /(? d)+/;
$::digit->[0] = 99;
$::digit->[1] = 88;
print "Modified string is: " . rebuild("1234"); # "998834"

# (?*...): upto a certain pattern
$text = "this is some italic text";
$text =~ /((?*)) /; # $1 = "italic"

# (?+...): upto and including a certain pattern
$text = "this is some italic text";
$text =~ /((?+))/; # $1 = "italic"

# You can also use fonctions inside patterns:

sub foo {
return "foo";
}

"foo bar" =~ /((?&foo()))/; # $1 => "foo"

Rexexp::Extended is a simple wrapper arround the perl rexexp syntax. It uses the overload module to parse constant qr// expressions and substitute known operators with an equivalent perl re.

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

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.

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

Visual REGEXP project can easily design and debug regular expressions by providing a graphical visualization of the expression and its matches on a sample of your choice.
Version restrictions:
- some regexp can consume a lot of CPU time. This seems to be caused by the use of -all, -inline and -indices flags together.
- when a subexpression is not matched (empty match), the last character of the previous match are coloured. This is due to a problem in Tcl (bug submitted to Scriptics).
Enhancements:
- new version done by Martin Lemburg. Many thanks, Martin.
- it is now a tcl 8.5a4 starpack
- GUI layout changed to be based on a paned window
- GUI code looks different, to be more ergonomic
- the informational labels (replacements & matches) are now sunken
- there are now additional the "first" and "last" navigation buttons
- there is a new option to navigate through matches or matches and submatches
- the displayed count of matches is changed to display the current and the count of matches used for navigation (probably changes, if the new navigation option is changed)
- the replace widget is disabled on startup
- the tcl console is added to the help menu
- the key bindings inside the regexp text widget changed a bit to allow for expanded regexp (-expanded or (?x)) to contain tabs and newlines. Tabs are created with Control-Tab and newlines with Control-Return. Additional with Control-C|V|X (not c|v|x) it is possible to use the clipboard like with Control|Shift-Insert, Shift-Delete.

Regexp::Common::time Perl module contains date and time regexps.

SYNOPSIS

use Regexp::Common qw(time);

# Piecemeal, Time::Format-like patterns
$RE{time}{tf}{-pat => pattern}

# Piecemeal, strftime-like patterns
$RE{time}{strftime}{-pat => pattern}

# Match ISO8601-style date/time strings
$RE{time}{iso}

# Fuzzy date patterns
# YEAR/MONTH/DAY
$RE{time}{ymd} # Most flexible
$RE{time}{YMD} # Strictest (equivalent to y4m2d2)
# Other available patterns: y2md, y4md, y2m2d2, y4m2d2

# MONTH/DAY/YEAR (American style)
$RE{time}{mdy} # Most flexible
$RE{time}{MDY} # Strictest (equivalent to m2d2y4)
# Other available patterns: mdy2, mdy4, m2d2y2, m2d2y4

# DAY/MONTH/YEAR (European style)
$RE{time}{mdy} # Most flexible
$RE{time}{MDY} # Strictest (equivalent to d2m2y4)
# Other available patterns: dmy2, dmy4, d2m2y2, d2m2y4

# Fuzzy time pattern
# HOUR/MINUTE/SECOND
$RE{time}{hms} # H: matches 1 or 2 digits; 12 or 24 hours
# M: matches 2 digits.
# S: matches 2 digits; may be omitted
# May be followed by "a", "am", "p.m.", etc.

This module creates regular expressions that can be used for parsing dates and times. See Regexp::Common for a general description of how to use this interface.

Parsing dates is a dirty business. Dates are generally specified in one of three possible orders: year/month/day, month/day/year, and day/month/year. Years can be specified with four digits or with two digits (with assumptions made about the century). Months can be specified as one digit, two digits, as a spelled-out name, or as a three-letter abbreviation. Day numbers can be one digit or two digits, with limits depending on the month (and, in the case of February, even the year). Also, different people use different punctuation for separating the various elements.
A human can easily recognize that "October 21, 2005" and "21.10.05" refer to the same date, but its tricky to get a program to come to the same conclusion. This module attempts to make it possible to do so, with a minimum of difficulty.

If you know the exact format of the data to be matched, use one of the specific, piecemeal pattern builders: tf or strftime. If there is some variability, use one of the fuzzy-matching patterns in the dmy, mdy, or ymd families. If the data are wildly variable, such as raw user input, give up and use the Date::Manip or Date::Parse module.

Time values are generally much simpler to parse than date values. Only one fuzzy pattern is provided, and it should suffice for most needs.

Regexp::Log::BlueCoat is a regexp builder to parse BlueCoat log files.

SYNOPSIS

my $blue = Regexp::Log::BlueCoat->new(
format => %g %e %a %w/%s %b %m %i %u %H/%d %c,
capture => [qw( host code )],
);

# the format() and capture() methods can be used to set or get
$blue->format(%g %e %a %w/%s %b %m %i %u %H/%d %c %f %A);
$blue->capture(qw( host code ));
$blue->ufs( smartfilter );

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

# the all-powerful capturing regex :-)
my $re = $blue->regex;

while () {
my %data;
@data{@fields} = /$re/;

# do something with the fields
}

Regexp::Log::BlueCoat is a module that computes custom regular expressions to parse log files generated by the BlueCoat Sytems Port 80 Security Appliance.
See the Regexp::Log documentation for a description of the standard Regexp::Log interface.