Free language translation software for linux

Language::Functional is a Perl module which makes Perl slightly more functional.

SYNOPSIS

use Language::Functional :all;
print The first ten primes are: ,
show(take(10, filter { prime(shift) } integers)), "n";

Perl already contains some functional-like functions, such as map and grep. The purpose of this module is to add other functional-like functions to Perl, such as foldl and foldr, as well as the use of infinite lists.

Think as to how you would express the first ten prime numbers in a simple way in your favourite programming language? So the example in the synopsis is a killer app, if you will (until I think up a better one.

The idea is mostly based on Haskell, from which most of the functions are taken. There are a couple of major omissions: currying and types. Lists (and tuples) are simply Perl list references, none of this cons business, and strings are simple strings, not lists of characters.

The idea is to make Perl slightly more functional, rather than completely replace it. Hence, this slots in very well with whatever else your program may be doing, and is very Perl-ish. Other modules are expected to try a much more functional approach.

Plone Language Tool is a product which allows you to set the available languages in your Plone site.
PloneLanguageTool allows you to set the available languages in your Plone site, select various fallback mechanisms, and control the use of flags for language selection and translations.
When installed, a new Plone control panel action will allow you to select various language options, such as the default and list of allowed languages.
PloneLanguageTool is shipped with Plone beginning in version 2.1 and up.
Enhancements:
- Bug fix release included in Plone 2.5.2.

Language::Logo Perl module is an implementation of the Logo programming language.

SYNOPSIS

use Language::Logo;

my $lo = new Logo(update => 20);

$lo->command("setxy 250 256");
$lo->command("color yellow");
$lo->command("pendown");

# Draw a circle
for (my $i = 0; $i < 360; $i += 10) {
$lo->command("forward 10; right 10");
}

$lo->disconnect("Finished...")

This module provides an implementation of the Logo programming language, with all of the necessary drawing primitives in a Tk Canvas. The Canvas object is also referred to as the "screen".

The first construction of a Language::Logo object causes a server to be created in a separate process; this server then creates a Tk GUI with a Tk::Canvas for use by the clients "turtle", and responds to all requests from the clients commands. In this way, multiple clients may be constructed simultaneously -- each one with its own "turtle".

In this first release, not all of the Logo language is implemented. Rather, the primary commands available are those which directly affect the turtle, and are related to drawing on the screen. The intent is to use the Logo in conjunction with Perl as a sort of "hybrid" language; Perl us used as the higher-level language layer through which all loop constructs, conditionals, and data-manipulation is done. This allows for a substantial level of programming power.

Language::Basic::Expression is a Perl package to handle string, numeric, and boolean expressions.

SYNOPSIS

See Language::Basic for the overview of how the Language::Basic module works. This pod page is more technical.
# Given an LB::Token::Group, create an expression I parse it
my $exp = new LB::Expression::Arithmetic $token_group;
# Whats the value of the expression?
print $exp->evaluate;
# Perl equivalent of the BASIC expression
print $exp->output_perl;

Expressions are basically the building blocks of Statements, in that every BASIC statement is made up of keywords (like GOTO, TO, STEP) and expressions. So expressions include not just the standard arithmetic and boolean expressions (like 1 + 2), but also lvalues (scalar variables or arrays), functions, and constants. See Language::Basic::Syntax for details on the way expressions are built.

BASIC expressions are represented by various objects of subclasses of Language::Basic::Expression. Most LB::Expressions are in turn made up of other LB::Expressions. For example an LBE::Arithmetic may be made up of two LBE::Multiplicative and a "plus". "Atoms" (indivisible LBEs) include things like LBE::Constants and LBE::Lvalues (variables).

Language::XSB is a Perl module that allows you to use XSB from Perl.

SYNOPSIS

use Language::XSB :query;
use Language::Prolog::Types::overload;
use Language::Prolog::Sugar vars=>[qw(X Y Z)],
functors=>{equal => =},
functors=>[qw(is)],
chains=>{plus => +,
orn => ;};

xsb_set_query( equal(X, 34),
equal(Y, -12),
is(Z, plus( X,
Y,
1000 )));

while(xsb_next()) {
printf("X=%d, Y=%d, Z=%dn",
xsb_var(X), xsb_var(Y), xsb_var(Z))
}

print join("n", xsb_find_all(orn(equal(X, 27),
equal(X, 45)), X)), "n";

ABSTRACT

Language::XSB provides a bidirectional interface to XSB (http://xsb.sourceforge.net/).

From the XSB manual:

XSB is a research-oriented Logic Programming and Deductive
Database System developed at SUNY Stony Brook. In addition to
providing all the functionality of Prolog, it contains
features not usually found in Logic Programming Systems such
as evaluation according to the Well Founded Semantics through
full SLG resolution, constraint handling for tabled programs,
a compiled HiLog implementation, unification factoring and
interfaces to other systems such as ODBC, C, Java, Perl, and
Oracle

This package implements a bidirectional interface to XSB, thats means that Perl can call XSB that can call Perl back that can call XSB again, etc.:

Perl -> XSB -> Perl -> XSB -> ...

(Unfortunately, you have to start from Perl, XSB->Perl->... is not possible.)
The interface to XSB is based on the objects created by the package Language::Prolog::Types. You can also use Language::Prolog::Sugar package, a front end for the types package to improve the look of your source (just some syntactic sugar).

To make queries to XSB you have to set first the query term with the function xsb_set_query, and then use xsb_next and xsb_result to iterate over it and get the results back.

Only one query can be open at any time, unless when Perl is called back from XSB, but then the old query is not visible.

ADML language is a server-side scripting language with Mysql database suport.

About Apache:

Apache HTTP Server is a free software/open source HTTP web server for Unix-like systems (BSD, Linux, and UNIX systems), Microsoft Windows, Novell NetWare and other platforms. Apache is notable for playing a key role in the initial growth of the World Wide Web, and continues to be the most popular web server in use, serving as the reference platform against which other web servers are designed and judged.

Apache features highly configurable error messages, DBMS-based authentication databases, and content negotiation. It is also supported by several graphical user interfaces (GUIs) which permit easier, more intuitive configuration of the server.
The Apache HTTP Server is developed and maintained by an open community of developers under the auspices of the Apache Software Foundation.

Language::Basic::Variable is a Perl module to handle parsing and implementing BASIC variables.

SYNOPSIS

See Language::Basic for the overview of how the Language::Basic module works. This pod page is more technical.
There are two sorts of variables: Arrays and Scalars. Each of those classes has a subclass for Numeric or String variables.

An Array needs to have full LBV::Scalar objects in it, rather than just having an array of values. The reason is that, for example, you might use ARR(3) as the variable in a FOR loop. Also, the "set" and "value" methods apply to a LBV::Scalar (since you cant set an array to a value (in BASIC) so in order to be handle A(3)=3, A(3) needs to be an LBV::Scalar.

The lookup method looks up a variable in the Array or Scalar lookup table (depending on whether there were parentheses after the variable name). BASIC allows undeclared variables, so if the variable name hasnt been seen before, a new variable is created.

Language::Basic::Variable::Scalar class

This class handles a variable or one cell in an array.

Methods include "value", which gets the variables value, and "set", which sets it.

Language::Basic::Variable::Array class

This class handles a BASIC array. Each cell in the array is a LBV::Scalar object.

Methods include "dimension", which dimensions the array to a given size (or a default size) and get_cell, which returns the LBV::Scalar object in a given array location.

Note that BASIC arrays start from 0!

Objective Modula-2 programming language is a hybrid between Smalltalk and Modula-2 based on the object model and runtime of Objective-C.

The design is an example how native Cocoa/GNUstep support can be added to static imperative programming languages without implementing a bridge.

The projects scope encompasses the design of the Objective Modula-2 programming language and the implementation of a compiler to implement it. The initial compiler will generate Objective-C source code.