Free mailgraph 1.12 software for linux

SableVM is a robust, extremely portable, efficient, and specifications-compliant Java virtual machine that aims to be easy to maintain and to extend.
It features a state-of-the-art and efficient interpreter engine. Its source code is very accessible and easy to understand. It also has many robustness features that have been the object of careful design.
SableVM is a clean-room implementation of the publicly available specifications.
Main features:
- Clean code, with minimal duplication, thanks to a set of easy-to-use indent-friendly m4 macros.
- Modularity, making it ideal for research into different implementations of VM components.
- Standards compliance (C, POSIX, JVM, JNI, JLS).
- Three different interpreter engines, of which the basic switch interpreter is perfect for debugging, and the inlined-threaded interpreter is competitively fast. See [Execution Engines]?.
- A nice development environment, thanks to the above features. New contributors can start grokking it easily.
- Use of the latest GNU Classpath. We frequently synchronize with the GNU Classpath CVS.
- Portability (record time is 1 hour for a new port).
- Permissive LGPL license.
- A retargettable just-in-time compiler, SableJIT, which currently runs on ppc, x86, and sparc. The initial implementation is almost ready.
- Proper implementation of the invocation interface, which makes it possible to execute Java code from an application written in a different language. SableVM was designed so that extending it to follow the full specifications is straightforward, and allows for many virtual machines to be created, run, and destroyed within a single process (still not fully complete). This is something that the official Sun implementation does not provide.

Rats! is an easily extensible parser generator for C-like languages; though currently it only generates parsers in Java. Rats! project has been explicitly designed so that grammars are concise and easily modifiable. To this end, Rats!
- organizes grammars into modules,
- builds on parsing expression grammars instead of context-free grammars and vintegrates lexing with parsing, i.e., is scannerless,
- supports the automatic generation of abstract syntax trees,
- and provides a well-defined interface for extending parsers to recognize context-sensitive languages and formats.
Parsers generated by Rats! memoize intermediate results, which ensures linear time performance in the presence of unlimited lookahead and backtracking. As a result, they are essentially functional (even though they are implemented in an imperative language) and also called "packrat parsers."
Main features:
- Rats! relies on a module system to structure grammars and their extensions. In particular, it relies on modules to group related productions into separate units. Next, module modifications concisely express extensions to other modules and can add, change, or remove individual alternatives in productions. Finally, module parameters are used to compose modules and their extensions with each other.
- Rats! grammars build on parsing expression grammars (PEGs). While PEGs share many constructs with the familiar EBNF notation, a key difference is that they utilize ordered choices instead of the unordered choices used by context-free grammars (CFGs) and other parser generators, such as Yacc or ANTLR. As a result, Rats! grammars avoid ambiguities and support localized changes. Additional flexibility is offered through syntactic predicates, which match expressions but do not consume the input, thus providing unlimited lookahead, and through the integration of lexing with parsing, which greatly simplifies the addition of new tokens to a grammar. PEGs have the additional benefit that they are not only closed under composition (unlike the LR or LL grammars used by Yacc and ANTLR), but also intersection and complement (unlike CFGs in general).
- To eliminate the need for explicit semantic actions, Rats! can automatically generate abstract syntax trees. In particular, it supports productions that return no semantic values (such as those recognizing spaces or comments), string values (such as those recognizing literals or identifiers), and generic tree nodes (potentially all other productions).
- Since some computer-readable formats are inherently context-sensitive and cannot be expressed as PEGs (or CFGs), Rats! supports two techniques for managing parser context or state, thus providing a well-defined interface for extending parsers. First, Rats! provides parser actions to recognize expressions that depend on local context, i.e., expressions that depend on immediately preceding expressions within the same production. An example for such local context is an explicit length preceding as many instances of some expression. Second, Rats! supports a global state object to recognize expressions that depend on possibly global context. State modifications are performed within lightweight transactions, which preserve the basically functional nature of Rats!-generated parsers. An example for a global context is the symbol table used for disambiguating variable and typedef names when parsing C.
Enhancements:
- Release highlights are support for formatting-preserving source refactorings through parse trees, support for parsing and pretty printing Java 5, (an improved abstract syntax tree for Java, and improved support for type checking C and Java ASTs.

Kraken provides a knowledge management system.
Kraken is an application for managing knowledge objects, which can be documents, remote or locally cached Web pages, personal information, todo list items, appointments, and so on. It is especially useful for researchers or students to manage their information.
Users can annotate these knowledge objects with metadata, perform complex queries, and present the results as HTML pages.
Kraken uses RDF as its native format, allowing its data to be easily read by external applications.
Enhancements:
- ugfixes, editing improvements.
- It is a relatively stable release, used by the author on a day to day basis.
- Expect mostly bugfix releases from now as the development shifted to the upcoming Java version.

XML::EasyOBJ is an easy XML object navigation.

SYNOPSIS

# open exisiting file
my $doc = new XML::EasyOBJ(my_xml_document.xml);
my $doc = new XML::EasyOBJ(-type => file, -param => my_xml_document.xml);

# create object from XML string
my $doc = new XML::EasyOBJ(-type => string, -param => $xml_source);

# create new file
my $doc = new XML::EasyOBJ(-type => new, -param => root_tag);

# read from document
my $text = $doc->some_element($index)->getString;
my $attr = $doc->some_element($index)->getAttr(foo);
my $element = $doc->some_element($index);
my @elements = $doc->some_element;

# first "some_element" element
my $elements = $doc->some_element;
# list of "some_element" elements
my @elements = $doc->some_element;

# write to document
$doc->an_element->setString(some string)
$doc->an_element->addString(some string)
$doc->an_element->setAttr(attrname, val)
$doc->an_element->setAttr(attr1 => val, attr2 => val2)

# access elements with non-name chars and the underlying DOM
my $element = $doc->getElement(foo-bar)->getElement(bar-none);
my $dom = $doc->foobar->getDomObj;

# get elements without specifying the element name
my @elements = $doc->getElement();
my $sixth_element = $doc->getElement(, 5);

# remove elements/attrs
$doc->remElement(tagname, $index);
$doc->tag_name->remAttr($attr);

# remap builtin methods
$doc->remapMethod(getString, s);
my $text = $doc->some_element->s;

I wrote XML::EasyOBJ a couple of years ago because it seemed to me that the DOM wasnt very "perlish" and the DOM is difficult for us mere mortals that dont use it on a regular basis. As I only need to process XML on an occasionally I wanted an easy way to do what I needed to do without having to refer back to DOM documentation each time.

A quick fact list about XML::EasyOBJ:

* Runs on top of XML::DOM
* Allows access to the DOM as needed
* Simple routines to reading and writing elements/attributes