Free expressions software for linux

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.

libvarexp is a C++ library that allows its users to detach any kind of information from the representation of that information by providing a simple-to-use but powerful text-template mechanism.

Similar mechanisms have been available in tools like sh(1), make(1), or perl(1) forever and have proven to be very useful.

The basic idea is that the relevant information is made available in variables, which the author of the template can than use within the text itself as he or she sees fit.

Consider, for example, a tool that will calculate the monthly financial reports of a small company.

Such a program should only calculate the required values, it should not worry about writing the resulting reports into an HTML file, a CSV file, or whatever format is desired. Instead, it should make the results of the calculation available in the variables "$TURNOVER", "$PROFIT", and "$INCREASE".

Then, using libvarexp, it could load an arbitrary template file and have the actual values inserted at the apropriate positions. Without changing a single line of code, one could generate the monthly report in HTML

Java Unified Expression Language is an implementation of the unified expression language (EL) as specified by the JSP 2.1 standard (JSR-245).
The javax.el.ExpressionFactory implementation is de.odysseus.el.ExpressionFactoryImpl:
// create an expression factory
javax.el.ExpressionFactory factory = new de.odysseus.el.ExpressionFactoryImpl();
Package de.odysseus.el.util provides ready-to-use subclasses of javax.el.ELContext and javax.el.ELResolver:
// create a simple EL context
de.odysseus.el.util.SimpleContext context =
new de.odysseus.el.util.SimpleContext(new de.odysseus.el.util.SimpleResolver());
// define function math:max(int,int)
context.setFunction("math", "max", Math.class.getMethod("max", new Class[]{int.class, int.class}));
// define variable "foo"
context.setVariable("foo", factory.createValueExpression(0, null));
// create expression
javax.el.ValueExpression e = factory.createValueExpression(context, "${math:max(foo,bar)}", null);
// set value for top-level property "bar"
context.setValue(null, "bar", 1);
// evaluate expression...
System.out.println(e.getValue(context)); // --> 1
The JUEL jar may be run from the command line to dump the parse tree of an EL expression:
$ java -jar juel-2.1.x.jar "#{unified(expression[language])}"
+- #{...}
|
+- unified(...)
|
+- [...]
|
+- expression
|
+- language
Enhancements:
- Minor changes only since the last release candidate.
- A detailed list of changes is contained in the archives.

RegExplorer project is a regular Expression Explorer.

It allows for writing regular expressions and visually see the matches, thus making regular expression much easier to write and maintain.

contraccions project is a program to validate word contractions in the Catalan language.

Word contractions in Catalan spelling are very complex and the function enclosed in this package allows a spellchecker to warn about wrong expressions and to suggest something to correct them.

It returns a code to indicate the type of the error and the location of the error in the expression, and allows a spellchecker to perform incremental validation.

GRegExp Explorer is a graphical regular expression explorer based on the PCRE regular expression library. It is possible to test regular expressions on the fly and check the result in detail.

perlrecharclass package contains Perl regular expression character classes.

The top level documentation about Perl regular expressions is found in perlre.
This manual page discusses the syntax and use of character classes in Perl Regular Expressions.

A character class is a way of denoting a set of characters, in such a way that one character of the set is matched. Its important to remember that matching a character class consumes exactly one character in the source string. (The source string is the string the regular expression is matched against.)
There are three types of character classes in Perl regular expressions: the dot, backslashed sequences, and the bracketed form.

The dot

The dot (or period), . is probably the most used, and certainly the most well-known character class. By default, a dot matches any character, except for the newline. The default can be changed to add matching the newline with the single line modifier: either for the entire regular expression using the /s modifier, or locally using (?s).

Here are some examples:

"a" =~ /./ # Match
"." =~ /./ # Match
"" =~ /./ # No match (dot has to match a character)
"n" =~ /./ # No match (dot does not match a newline)
"n" =~ /./s # Match (global single line modifier)
"n" =~ /(?s:.)/ # Match (local single line modifier)
"ab" =~ /^.$/ # No match (dot matches one character)

Backslashed sequences

Perl regular expressions contain many backslashed sequences that constitute a character class. That is, they will match a single character, if that character belongs to a specific set of characters (defined by the sequence). A backslashed sequence is a sequence of characters starting with a backslash. Not all backslashed sequences are character class; for a full list, see perlrebackslash.

Heres a list of the backslashed sequences, which are discussed in more detail below.

d Match a digit character.
D Match a non-digit character.
w Match a "word" character.
W Match a non-"word" character.
s Match a white space character.
S Match a non-white space character.
h Match a horizontal white space character.
H Match a character that isnt horizontal white space.
v Match a vertical white space character.
V Match a character that isnt vertical white space.
pP, p{Prop} Match a character matching a Unicode property.
PP, P{Prop} Match a character that doesnt match a Unicode property.