Free ll software for linux

ll-toxic helps to generate Oracle database functions that return XML strings by allowing you to embed processsing instructions containing PL/SQL code in XML.
Enhancements:
- The API has changed so that encodings other than ISO-8859-1 are now supported.

LLg is a recursive descent parser generator.

SYNOPSIS

use LLg;
@tokens = (
ADDOP => [-+],
LEFTP => [(],
RIGHTP => [)],
INTEGER => 0|[1-9][0-9]*,
);
$reader = Lex->new(@tokens);
$ADDOP->debug;

$expr = And->new(($factor, Any->new($ADDOP, $factor)),
sub {
shift(@_);
my $result = shift(@_);
my ($op, $integer);
while ($#_ >= 0) {
($op, $integer) = (shift(@_), shift(@_));
if ($op eq +) {
$result += $integer;
} else {
$result -= $integer;
}
}
$result;
});
$factor = Or->new($INTEGER, $parexp);
$parexp = And->new($LEFTP, $expr, $RIGHTP,
sub { $_[2] });

print STDERR "Type your arithmetic expression: ";
print "Result: ", $expr->next, "n";

Creating parsers by hand is tedious even for simple languages. This activity can be automated by parser-generators - yacc is a well-known example. But using such tools is quite demanding and requires a reasonable knowlege of the principles of syntactic analysis.

LLg is a set of Perl5 packages which allow the generation of recursive descent parsers for context-free grammars.

LLg is provided with the packages Lex and Token which are object-based. The use of these packages presupposes that you know how to write a BNF grammar and that you know (just a little) about programming in Perl.

Specifying the parser does not require any extension to Perl syntax. The specification is carried out entirely in standard Perl, be it definition of tokens, syntactic rules or associated semantic actions. LLg allows the easy specification of translation schemes, that is parsers for which the semantic action is given by actions directly associated with each production.

The packages Token and LLg allow respectively the definition of objects corresponding to terminals (tokens) and non-terminals of the grammar. Lex handles the reading and "eating" of tokens in the input stream.

Before using these packages you need to define a BNF grammar without left recursion (an LL(1) grammar). Given this, making the parser consists in:

1. create a lexical analyser by specifying the terminals,
2. create a parser (syntactic analyser) by creating a LLg object (or, more precisely, one of the packages which inherits from LLg) for each non-terminal.
3. define the semantics by associating an anonymous function with each LLg object.

Take as an example arithmetic expressions having only + and - as operators. In the Camel book we find the following grammar:

expr ::= factor { ADDOP factor }
ADDOP ::= + | -
factor ::= NUMBER | ( expr )

Creating the parser for this language involves defining a lexical analyser and a syntactic analyser.

The lexical analyser is defined thusly:

@tokens = (
ADDOP => [-+],
LEFTP => [(],
RIGHTP => [)],
INTEGER => [1-9][0-9]*,
);
$reader = Lex->new(@tokens);

The argument of the method new() is a list of pairs: the identity of the terminal and the corresponding regular expression. Each such pair leads to the creation of a terminal of type Token.

The package LLg is the base package of a set : And, Any, Do, Hook, Opt, Or. These packages allow the creation of the different types of rules normally found in context-free grammars. We use a prefix notation with the following equivalences.

A | B Or->new($A, $B) symbol A or symbol B


A B And->new($A, $B) symbol A followed by symbol B


{ A } Any->new($A) arbitrary number of A


[ A ] Opt->new($A) zero or one occurrence of A

The rules in our example are given by creating the following objects:

$expr = And->new(($factor, Any->new($ADDOP, $factor));
$factor = Or->new($NUMBER, $parexp);
$parexp = And->new($LEFTP, $expr, $RIGHTP);

The arguments of the method new() are references to LLg or Token objects. (The written order of the rule has no significance, since scalars can be references before they are assigned a value. These references are resolved when each object is used. As the example shows, references can be obtained to the objects returned by a rule.)

The semantics is defined by putting an anonymous function at the end of the list of object references. The anonymous function uses information associated with the objects. This information is transmitted by positional parameters (the array @_). The nth argument designates the result of the nth parameter of the method new(). Information returned by the function is associated with the object and is transmitted by means of positional parameters wherever the object is used. In our example we will have:

$expr = And->new(($factor, Any->new($ADDOP, $factor)),
sub {
shift(@_);
my $result = shift(@_);
my ($op, $integer);
while ($#_ >= 0) {
($op, $integer) = (shift(@_), shift(@_));
if ($op eq +) {
$result += $integer;
} else {
$result -= $integer;
}
}
$result;
});
$factor = Or->new($INTEGER, $parexp);
$parexp = And->new($LEFTP, $expr, $RIGHTP,
sub { $_[2] });

print STDERR "Type your arithmetic expression: ";
print "Result: ", $expr->next, "n";

When an integer is recognised it is returned by the anonymous function associated with the object $factor. This returned information (or, more precisely, synthesised, since it comes from a a terminal and is transmitted to non-terminals) is also available in the anonymous function associated with the object $expr. The information returned by the following object is used to calculate the value of the arithmetical expression.

The analyser is started up by applying the method next() to the axiom of the grammar:

$expr->next;

By default the input for analysis is read from the standard input. The example parser analyses and interprets individual expressions typed in at the terminal. The example calculator.pl delivered with the LLg package shows how to create an input loop allowing reading and interpretation of arbitrary many expressions.
The parser generator can be used for other purposes than the analysis of a character stream. Given that the packages Lex, LLg and Token, it is perfectly possible to define terminals which are objects i.e. instances of a class other than Token. Each new package defining terminals ought at least to have the methods status() and next() - see vonkoch.pl as an example.

Text::NSP::Measures::2D::MI::ll is a Perl module that implements Loglikelihood measure of association for bigrams.

SYNOPSIS

Basic Usage

use Text::NSP::Measures::2D::MI::ll;

my $npp = 60; my $n1p = 20; my $np1 = 20; my $n11 = 10;

$ll_value = calculateStatistic( n11=>$n11,
n1p=>$n1p,
np1=>$np1,
npp=>$npp);

if( ($errorCode = getErrorCode()))
{
print STDERR $errorCode." - ".getErrorMessage();
}
else
{
print getStatisticName."value for bigram is ".$ll_value;
}

BeatrIX Linux 2005.1 FINAL is a less-than-200-meg Debian/Ubuntu Linux that is a live-CD/installable to hard drive distribution featuring kernel 2.6.7, Gnome 2.8.1, Firefox 1.03 w/AdBlock, Evolution 2.01, GAIM 1.03, Open Office 1.1.2, Apt, PDF viewer, image viewer, plus much, much more. It is expandable through both the Debian and Ubuntu repositories and is one of the fastest-growing Linuxes in the world.
It is a "get-the-job-done distribution of Linux and because of its design, will run on just about any personal computer made in the past 10 years with a minimum of 64 megabytes of RAM.
The programs chosen for BeatrIX are all "best-of-breed" meaning weve selected the best of the best of each type of program.
If you install it to hard drive, you can upgrade and add to the system using the Ubuntu and/or Debian file repositories, turning it into just about any type of operating system you want. You can install everything from Web servers to Wed editors. And ll of this from a mini-CD!
It is one of the fastest-growing Linuxes in the world, having been downloaded in more than 110 countries and more than 50,000 times since its release four months ago.

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.

La-Nai is a CMS-like system that has basic modules, blocks, and templates.
The project is ready to create a Web site, but it has a new way of development called "Generated Framework", which means that a developer can generate module and source code from a command line script called "La-Mud".
In just a few minutes, you can create your own module or database driven module.
Installation:
1. Download release version at sourceforge
2. Extract to your home directory
3. Browse to http://your-domain-name/lanai-dir/
4. It ll start web installation follow the instruction until finish
5. Delete install directory after finish.
Enhancements:
- Multiple SQL injection vulnerabilities were fixed in three modules.

Spirit is an object oriented recursive descent parser generator framework implemented using template meta-programming techniques. Expression templates allow us to approximate the syntax of Extended Backus Normal Form[1] (EBNF) completely in C++.
Parser objects are composed through operator overloading and the result is a backtracking LL(inf) parser that is capable of parsing rather ambiguous grammars.
The Spirit framework enables a target grammar to be written exclusively in C++. Inline EBNF grammar specifications can mix freely with other C++ code and, thanks to the generative power of C++ templates, are immediately executable. In retrospect, conventional compiler-compilers or parser-generators have to perform an additional translation step from the source EBNF code to C or C++ code.
Spirit is part of Boost Libraries, a peer-reviewed, open collaborative development effort.
Enhancements:
- Fixed bug where a match is a variant.
- added Jamfile/Jamrules from CVS to spirit-1.8.1/
- added boost-build.jam from boost to spirit-1.8.1/
- disabled template multi-threading in libs/spirit/test/Jamfile
- added a boost-header-include rule (from spirit-header-include) pointing to miniboost in libs/spirit/test/Jamfile
- Fixed if_p inconsistency

Common Text Transformation Library, CTTL for short, is a set of C++ classes and functions to understand and modify text data. Common Text Transformation Library implementation is based on STL classes and algorithms.
Concept of a substring plays major role in design of the text transformation library. CTTL substring is an object that interacts with fragments of text encapsulated by STL std::basic_string template class.
Template classes cttl::const_edge and cttl::edge, designed for constant and mutable data access, respectively, represent CTTL substrings. Substrings may be compared, inserted, deleted, or replaced across multiple text inputs. If content of text mutates, the substrings adjust their positions accordingly to the change. CTTL guarantees that substrings remain stable with respect to a potentially mutable text.
Within CTTL framework, a substring may be parsed with EBNF-like grammar. CTTL lexical analysis engine generates a stream of substrings corresponding to the parsed symbols. BNF and EBNF grammars can be written directly in C++.
Template meta-programming and operator overloading offer features to write C++ expressions that describe grammar rules. No additional steps of parsing, compiling, or generating source code are required. Compiled CTTL program implements LL(INF)-parser, the recursive-descent parser with infinite lookahead.
Enhancements:
- This release focuses on documentation enhancements, which include multiple documentation improvements and revisions.
- An alphabetical index of all CTTL facilities was added: http://cttl.sourceforge.net/documentation_idx.html.