Free tcl regexp 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.

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

eTcl is a "batteries-included", thread-enabled Tcl/Tk runtime, available as a single standalone executable. eTcl includes several popular extensions (Sqlite, Thread, Zlib, ...), together with a Tcl wrapper for the Pixane image processing library.
Installation:
Just copy executable wherever you want on your device (memory or storage card), and launch it.
- Unobstrusive executable. No registry to set, no external dependencies.
- Standalone executable. Tcl and Tk scripts packed into executable (using VFS). Optimized startup time.
New Tcl user experience on PocketPC
- Optimized for XScale devices
- Faster Arc/Chord/Pie emulation, improved for ARM architecture without FPU
- Efficient WSAAsyncSelect() emulation. Sockets, and fileevents on sockets, should be fully functionnal (in both client and server modes)
- Support for native menu
- Improved native look and feel.
- Windows Mobile specific extension: manage SIP, change (X) button action (closing Correct handling of mouse (actually touchscreen) events
- Support for intercepting hotkeys (calendar, notes, etc...)
- New porting approach, based on very minor changes to generic Win32 port (and no changes to generic part of Tcl/Tk distrib).
- Patch to Tcl or Tk distribution is only few kilobytes large, everything else has been moved into a minimal emulation library. This should allow us to keep synced with future Tcl/Tk release.
- Easy build process. Nothing but Evc4 and a native Tcl interpreter required to build binaries for all target architectures supported by Evc (Cygwin, external libraries, etc... not required)
- Works fine into Microsoft Pocket PC 2003 Emulator. Debugging code made easier
Included native extensions:
- Pixane: script your image transformation, support for reading and writing several popular image formats (PNG, JPEG), support for TrueType fonts
- Sqlite 3: a self-contained, embeddable, zero-configuration SQL database engine
- Zlib: native deflate/inflate support
- Zipfs: easily Mount your ZIP files into Tcl Virtual Filesystem
Included Pure Tcl extensions:
- EvoTcl: A very large set of tcl utilities (OOP, Database, HTML/XML parsing, ...). See http://www.evolane.com/software/evotcl/
Enhancements:
- This release focuses on performance optimization (especially for WinCE) and code stabilization.
- It adds support for reading tclkits, together with an automatic tclkit to eTcl kit converter.
- It embeds up-to-date versions of several built-in packages, such as sqlite 3.4.1, libpng 1.2.18, and tile and tkhtml3 CVS snapshots.
- Tile has been moved into the normal version.
- The Mac OS X bundle declares associations so eTcl kits can be launched directly from the Finder.
- Binaries for linux-powerpc have been made compatible with Linux on Playstation 3.

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.

Wtcl is a Tcl module for Apache. It provides an embedded, persistent Tcl interpreter and a set of commands for developing dynamic Tcl-based web pages. mod_wtcl currently works with Tcl >= 8.1 and Apache 1.3.

Wtcl Commands

Web Request

params, queryParams, postParams, cookies, uploadSettings, uploads, upload, requestHeaders

Web Response

status, contentType, headers, cookie, responseCookies, sendHeaders, redirect, successHeaders

Session

session, procSession, dbSession

Page

include, includeString, loader, loaderInfo, pageIndex, pageStack

Server

serverVars, events, atEnd, virtual, serverLog, logLevel, printContext, workerInfo, taskInfo, requestTime, elapsedTime, sleep, wtVersion

Web Utilities

htmlEncode, urlEncode, urlDecode

Table Collection Utilities

table, appTable, ciTable

Application Data Source Utilities

registerDataSource, isDataSourceRegistered, openDataSource, closeDataSource, dbDriver

Hash Utilities

md5Encode

KLMCL is a graphical MUD client for KDE with support for aliases, regexp triggers, spellup spells management, key bindings More detailed information can be found under DocManager: Project Documentation.
Enhancements:
- Colour codes shouldnt break between buffers now.
- ANSI sequences besides colours are gracefully ignored instead of thrown away.
- Screen selections wont disappear.
- Random minor cleanups.

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

Myintcl is an interface for using MySQL in Tcl programs, and it is written only in pure Tcl. The API design of Myintcl library follows that of fbsql.