Free java text processing software for linux

Java Parallel Processing Framework is a set of tools and APIs to facilitate the parallelization of CPU intensive applications, and distribute their execution over a network of heterogenous nodes.
Java Parallel Processing Framework is intended to run in clusters and grids.
Main features:
- an API to delegate the processing of parallelized tasks to local and remote execution services
- a set of APIs and user interface tools to administrate and monitor execution services
- real-time adaptive load balancing capabilities
- scalability up to an arbitrary number of processing nodes
- support for failover and recovery
- limited intrusiveness for existing or legacy code
- a dynamic deployment mechanism, that enables the execution of new, or updated, code without having to deploy onto the grid
- fully documented APIs, administration guide and developer guide
- runs on any platform supporting Java 2 Platform Standard Edition 5.0 (J2SE 1.5)
Enhancements:
- JPPF is now licensed under the terms of the Apache License, Version 2.0. Starting from JPPF 1.0 beta1, all releases will be licensed under these terms.
- Prior versions will remain under the terms of the LGPL.
- For the first time, JPPF integrates seamlessly with J2EE. The JPPF Resource Adapter provides J2EE application servers with an access to native grid services.
- Numerous bug fixes, especially with regards to the distributed class loading mechanism.

Java::JCR::Exception is a Perl wrapper for repository exceptions.

SYNOPSIS

eval {
my $node = $root->add_node(foo, nt:unstructured);
};

if ($@) {
print STDERR "Failed to add node foo: $@n";
}

This class is used to make the exceptions thrown from the Java code work more nicely in Perl. Primarily, this involves performing nicer stringification than is provided by Inline::Java.

SJPT is parsing toolkit that supports both top-down (LL(1) and Simple Precedence) and bottom-up parsing (LR(0), SLR(1), LR(1) and LALR(1)).

The toolkit also supports generating Java parsers for all the bottom-up parsing methods, based on a CUP definition (similar to Yacc and CUP, but not restricted to LALR parsers only). I worked alone on this project for the laboratory on Compilers.

SJPT is free software under the terms of the GNU GPL.

Java-Chess project is a standalone Java chess program.

Java-Chess is a fully-featured chess program that uses using Java 1.2 (including Swing) and 64-bit computing where possible.

The goal of the Java-Chess project is to develop an OpenSource chess application written in Java. We want to demonstrate that Java can be tuned to a point, where it is almost up to the performance of an application, that was directly compiled to native code.

Even clean object-oriented design does not necessarily generate an overhead, that makes high-performance computing virtually impossible.

Java Web Shell is a web based interactive shell-type environment written in Java.

Obviously, to use the shell, youll need to be using a browser that supports Java Applets, and this has been compiled using the Sun 1.4.1 JDK.

Head over to Sun and pick up the latest runtime enviroment if you dont already have it.

Java Neural Network Trainer is a neural network trainer with the ability to easily add new training algorithms and training patterns.

Java Neural Network Trainer project includes a parallel training graphical interface where you can view each trainer working in real-time in parallel.

Text::MacroScript is a macro pre-processor with embedded perl capability.

SYNOPSIS

use Text::MacroScript ;

# new() for macro processing

my $Macro = Text::MacroScript->new ;
while( ) {
print $Macro->expand( $_ ) if $_ ;
}

# Canonical use (the filename improves error messages):
my $Macro = Text::MacroScript->new ;
while( ) {
print $Macro->expand( $_, $ARGV ) if $_ ;
}

# new() for embedded macro processing

my $Macro = Text::MacroScript->new( -embedded => 1 ) ;
# Delimiters default to
# or
my $Macro = Text::MacroScript->new( -opendelim => [[, -closedelim => ]] ) ;
while( ) {
print $Macro->expand_delimited( $_, $ARGV ) if $_ ;
}

# Create a macro object and create initial macros/scripts from the file(s)
# given:
my $Macro = Text::MacroScript->new(
-file => [ local.macro, ~/.macro/global.macro ]
) ;

# Create a macro object and create initial macros/scripts from the
# definition(s) given:
my $Macro = Text::MacroScript->new(
-macro => [
[ MAX_INT => 32767 ],
],
-script => [
[ DHM2S =>
[
my $s = (#0*24*60*60)+(#1*60*60)+(#2*60) ;
"#0 days, #1 hrs, #2 mins = $s secs"
],
],
-variable => [ *MARKER* => 0 ],
) ;

# We may of course use any combination of the options.

my $Macro = Text::MacroScript->new( -comment => 1 ) ; # Create the %%[] macro.

# define()

$Macro->define( -macro, $macroname, $macrobody ) ;

$Macro->define( -script, $scriptname, $scriptbody ) ;

$Macro->define( -variable, $variablename, $variablebody ) ;

# undefine()

$Macro->undefine( -macro, $macroname ) ;

$Macro->undefine( -script, $scriptname ) ;

$Macro->undefine( -variable, $variablename ) ;

# undefine_all()

$Macro->undefine( -macro ) ;

$Macro->undefine( -script ) ;

$Macro->undefine( -variable ) ;

# list()

@macros = $Macro->list( -macro ) ;
@macros = $Macro->list( -macro, -namesonly ) ;

@scripts = $Macro->list( -script ) ;
@scripts = $Macro->list( -script, -namesonly ) ;

@variables = $Macro->list( -variable ) ;
@variables = $Macro->list( -variable, -namesonly ) ;

# load_file() - always treats the contents as within delimiters if we are
# doing embedded processing.

$Macro->load_file( $filename ) ;

# expand_file() - calls expand_embedded() if we are doing embedded
# processing otherwise calls expand().

$Macro->expand_file( $filename ) ;
@expanded = $Macro->expand_file( $filename ) ;


# expand()

$expanded = $Macro->expand( $unexpanded ) ;
$expanded = $Macro->expand( $unexpanded, $filename ) ;

# expand_embedded()

$expanded = $Macro->expand_embedded( $unexpanded ) ;
$expanded = $Macro->expand_embedded( $unexpanded, $filename ) ;

This bundle also includes the macro and macrodir scripts which allows us to expand macros without having to use/understand Text::MacroScript.pm, although you will have to learn the handful of macro commands available and which are documented here and in macro. macro provides more documentation on the embedded approach.

The macroutil.pl library supplied provides some functions which you may choose to use in HTML work for example.