Free regexp like software for linux

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

ShiftJIS::Regexp contains regular expressions in Shift-JIS.

SYNOPSIS

use ShiftJIS::Regexp qw(:all);

match($string, p{Hiragana}{2}p{Digit}{2});
match($string, pH{2}pD{2});
# these two are equivalent:

This module provides some functions to use regular expressions in Shift-JIS on the byte-oriented perl.

The legal Shift-JIS character in this module must match the following regular expression:

[x00-x7FxA1-xDF]|[x81-x9FxE0-xFC][x40-x7Ex80-xFC]

To avoid false matching in multibyte encoding, this module uses anchoring technique to ensure each matching position places at the character boundaries.

cf. perlfaq6, "How can I match strings with multibyte characters?"

Functions

re(PATTERN)

re(PATTERN, MODIFIER)

Returns a regular expression parsable by the byte-oriented perl.

PATTERN is specified as a string. MODIFIER is specified as a string. Modifiers in the following list are allowed.

i case-insensitive pattern (only for ascii alphabets)
I case-insensitive pattern (greek, cyrillic, fullwidth latin)
j hiragana-katakana-insensitive pattern (but halfwidth katakana
are not considered.)

s treat string as single line
m treat string as multiple lines
x ignore whitespace (i.e. [x20nrtf]) unless backslashed
or inside a character class; but comments are not recognized!

o once parsed (not compiled!) and the result is cached internally.
o modifier
while ( ) {
print replace($_, (perl), $1, igo);
}
is more efficient than

while ( ) {
print replace($_, (perl), $1, ig);
}

because in the latter case the pattern is parsed every time
whenever the function is called.

match(STRING, PATTERN)

match(STRING, PATTERN, MODIFIER)

An emulation of m// operator aware of Shift-JIS. But, to emulate @list = $string =~ m/PATTERN/g, the pattern should be parenthesized (capturing parentheses are not added automatically).

@list = match($string, pH, g); # wrong; returns garbage!
@list = match($string,(pH),g); # good
PATTERN is specified as a string. MODIFIER is specified as a string.
i,I,j,s,m,x,o please see re().

g match globally
z tell the function the pattern matches an empty string
(sorry, due to the poor auto-detection)

replace(STRING or SCALAR REF, PATTERN, REPLACEMENT)

replace(STRING or SCALAR REF, PATTERN, REPLACEMENT, MODIFIER)

An emulation of s/// operator but aware of Shift-JIS.
If a reference to a scalar is specified as the first argument, substitutes the referent scalar and returns the number of substitutions made. If a string (not a reference) is specified as the first argument, returns the substituted string and the specified string is unaffected.

MODIFIER is specified as a string.

i,I,j,s,m,x,o please see re().
g,z please see match().

jsplit(PATTERN or ARRAY REF of [PATTERN, MODIFIER], STRING)

jsplit(PATTERN or ARRAY REF of [PATTERN, MODIFIER], STRING, LIMIT)

An emulation of CORE::split but aware of Shift-JIS.
In scalar/void context, it does not split into the @_ array; in scalar context, only returns the number of fields found.
PATTERN is specified as a string. But as PATTERN has no special meaning; it splits the string on a single space similarly to CORE::split / /.

When you want to split the string on whitespace, pass an undefined value as PATTERN or use the splitspace() function.

jsplit(undef, " x81x40 This is x81x40 perl.");
splitspace(" x81x40 This is x81x40 perl.");
# (This, is, perl.)

If you want to pass pattern with modifiers, specify an arrayref of [PATTERN, MODIFIER] as the first argument. You can also use "Embedded Modifiers").

MODIFIER is specified as a string.

i,I,j,s,m,x,o please see re().

splitspace(STRING)

splitspace(STRING, LIMIT)

This function emulates CORE::split( , STRING, LIMIT). It returns a list given by split STRING on whitespace including "x81x40" (IDEOGRAPHIC SPACE). Leading whitespace characters do not produce any field.

Note: splitspace(STRING, LIMIT) is equivalent to jsplit(undef, STRING, LIMIT).

splitchar(STRING)

splitchar(STRING, LIMIT)

This function emulates CORE::split(//, STRING, LIMIT). It returns a list given by split of STRING into characters.
Note: splitchar(STRING, LIMIT) is equivalent to jsplit(, STRING, LIMIT).

Regexp::Common::net is a Perl module that provide regexes for IPv4 addresses.

SYNOPSIS

use Regexp::Common qw /net/;

while () {
/$RE{net}{IPv4}/ and print "Dotted decimal IP address";
/$RE{net}{IPv4}{hex}/ and print "Dotted hexadecimal IP address";
/$RE{net}{IPv4}{oct}{-sep => :}/ and
print "Colon separated octal IP address";
/$RE{net}{IPv4}{bin}/ and print "Dotted binary IP address";
/$RE{net}{MAC}/ and print "MAC address";
/$RE{net}{MAC}{oct}{-sep => " "}/ and
print "Space separated octal MAC address";
}

Please consult the manual of Regexp::Common for a general description of the works of this interface.

Do not use this module directly, but load it via Regexp::Common.

This modules gives you regular expressions for various style IPv4 and MAC (or ethernet) addresses.

$RE{net}{IPv4}

Returns a pattern that matches a valid IP address in "dotted decimal". Note that while 318.99.183.11 is not a valid IP address, it does match /$RE{net}{IPv4}/, but this is because 318.99.183.11 contains a valid IP address, namely 18.99.183.11. To prevent the unwanted matching, one needs to anchor the regexp: /^$RE{net}{IPv4}$/.
For this pattern and the next four, under -keep (See Regexp::Common):

$1

captures the entire match

$2

captures the first component of the address

$3

captures the second component of the address

$4

captures the third component of the address

$5

captures the final component of the address