Free visual regexp 3.1 software for linux

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.

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.

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

Search::Tools::RegExp is a Perl module to build regular expressions from search queries.

SYNOPSIS

my $regexp = Search::Tools::RegExp->new();

my $kw = $regexp->build(the quick brown fox);

for my $w ($kw->keywords)
{
my $r = $kw->re( $w );

# the word itself
printf("the word is %sn", $r->word);

# is it flagged as a phrase?
print "the word is a phrasen" if $r->phrase;

# each of these are regular expressions
print $r->plain;
print $r->html;
}

Build regular expressions for a string of text.
All text is converted to UTF-8 automatically if it isnt already, via the Search:Tools::Keywords module.

Visual Oberon is a GUI library written in Oberon2.
VisualOberon (or short VO) is a collection of classes written in the programming language Oberon-2. The classes are designed to let application developer easyliy build graphical user interfaces for rograms written in Oberon-2. _VO_ is distributed nder the GNU library icense.
VisualOberon is _not_ a programming language. While it sounds like he Oberon version of VisualBasic, it is not an integrated developement nvirinment with build in text editor, builder and that stuff. It is urrently just a library. Nevertheless it can be the basis for such integrated environment.
Enhancements:
- Some prototype of a controller class for mapping input to object functionality.
- Improved Edit control.
- Improved file open dialog.
- Menu navigation via keyboard.
- More usage of STRING.
- Improved drawing including support for offscreen drawing.
- Improved Curses version, now works also on black white terminals - but still not perfect.
- Improved image loading.
- Bugfixes, bugfixes, bugfixes.
- Improvement of VGD. Added more VGD handler.
- Support for Xft version 2 as found in newer distributions.
- Packages for Windows and Carbon modules, needed for developing applications for Window sand Mac OS X, used by the coresponding driver module sin VisualOberon.

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.

Visual difference metrics can predict whether differences between two images are visible to the human observer or not. Such metrics are used for testing either visibility of information (whether we can see important visual information) or visibility of noise (to make sure we do not see any distortions in images, e.g. due to lossy compression).

The image below shows how two input images, a reference image (upper left) and a distorted image (lower left), are processed with the VDP to produce a probability of detection map (right). Such probability of detection map tells how likely we will notice a difference between two images for each part of an image.

Red color denotes high probability, green - low probability. Red color is mostly present in the areas where there is a snow covered path. Because of smooth texture of the snow, there is not much visual masking and distortions are easily visible.

Although there are dozens of visible difference metrics that serve a similar purpose, our Visual Difference Predictor for HDR images (HDR-VDP) has two unique advantages: firstly, our metric works with a full range of luminance values that can be meet in a real word (HDR images), and secondly, we offer a complete source code for free.

High Dynamic Range Visible Difference Predictor (HDR-VDP) can work within the complete range of luminance the human eye can see. An input to our metric is a high dynamic range (HDR) image, or an ordinary 8-bits-per-color image, converted to the actual luminance values. The proposed metric takes into account the aspects of high contrast vision, like scattering of the light in the optics (OTF), nonlinear response to light for the full range of luminance, and local adaptation.

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