Free language translators software for linux

Tiny Translator is a very simple class for easily organizing dialogue outputs and creating language tables for multilingual projects.
Tiny Translator uses flat files and does not require a database engine.
Enhancements:
- This release supports MySQL databases for storing phrases.
- It still supports flat files (comma separated).
- The translate() method was split into various methods.
- Deprecated elements were deleted.

wbmtranslator is a translation assistant for webmin/usermin modules.

wbmtranslator module is intended for webmin modules translators. It may not be usable with text only browsers like lynx or w3m. Also, please activate javascript in your browser settings.

X Language is a new multi-syntax programming including a portable set of APIs to create console or graphical applications runnable on many platforms (UNIX/X11, Win32, ...). X Language comes with an interpreter, a compiler and a debugger.
X Language is publicly available under the GPL.
Installation
- tar -xzf xlang-0.7.1.tar.gz
- cd xlang-0.7.1
- ./configure
- make
- make install
- ./xlc calc.xc
Enhancements:
- Adding LANG/MATH specifications
- Adding SYS (basic) specifications
- Start implementing the SCR API

V language is a tiny concatenative language implemented for experimentation.
The source is under Public Domain (un-copyrighted.)
The full featured language is on top of JVM, A native version (in alpha state) is also there in the codebase.
To run it, extract the distribution in any directory and do #gmake run.
gmake
gmake run
V
|
The language is a close relative of postscript, forth and joy. and is stack based. ie:
|2 3 *
=6
|2 3 * 5 +
=11
See status for a tutorial and more info.
The Functions available in V are available in this page: functions
(The releases are out of date and multiple fixes have gone in. Please check out and build rather than use them.)
Example functions in V. getting the roots (with out using the stack shuffling word view)
[quad-formula
[a b c] let
[minisub 0 b -].
[radical b b * 4 a * c * - sqrt].
[divisor 2 a *].
[root1 minisub radical + divisor /].
[root2 minisub radical - divisor /].
root1 root2
].
|2 4 -30 quad-formula ??
=(-5.0 3.0)
using view
[quad-root
[a b c : [0 b - b b * 4 a * c * - sqrt + 2 a * /]] view i
].
|2 4 -30 quad-root ??
=(3)
contrast this with the definition in scheme here
(define quadratic-formula
(lambda (a b c)
(let ([minusb (- 0 b)]
[radical (sqrt (- (* b b) (* 4 ( * a c))))]
[divisor (* 2 a)] )
let ([root1 (/ (+ minusb radical) divisor)]
[root2 (/ (- minusb radical) divisor)])
(cons root1 root2)))))
Definition of Qsort.
[qsort
#definitions
[joinparts [pivot [*list1] [*list2] : [*list1 pivot *list2]] view].
[split_on_first_element uncons [>] split&].
#args starts for binrec. notice that 2 arguments (termination condition
#and its result) are on first line.
[small?] []
[split_on_first_element]
#binrec recurses on the result of split_on_first_element before applying joinparts.
[joinparts]
binrec].
Some explanations.
The first and second lines (terminated by .) are internal function definitions
(Notice how qsort is also terminated by .) . is the definition syntax in V.
The first function joinparts
============================
The function joinpart contains just an application of the operator view.
view is list translator. It takes a list of the form [template : result]
then it tries to apply the template to the current stack. If it can be applied on the
stack, then the arguments named in the template are bound to values in stack. The result is then processed, and all the bound elements in result are replaced by their values.
[pivot [*list1] [*list2] : [*list1 pivot *list2]] view expects 3 arguments on the stack,
the first a single element pivot, then two lists list1 and list2.
It returns a list that is composed of elements of list1 followed by pivot
followed by elements of list2 (as defined in result - RHS of :).
ie:
44 [1 2 3] [5 6 7] [pivot [*list1] [*list2] : [*list1 pivot *list2]] view ??
=> [1 2 3 44 5 6 7]
(The function ?? is used to print out the elements in the stack now.)
The second function split_on_first_element
==========================================
The definition is [uncons [>] split&]
The uncons splits a list into the first element and the rest of the list.
ie:
[1 2 3 4 5] uncons ??
=1 [2 3 4 5]
split& takes two arguments, the first is the function F to split a list with,
and the second the list itself. All elements in the list that passes the function F
is put into the first list, and all that do not are put into the second list.
ie:
[1 2 3 4 5 6 7] [4 >] split& ??
=[5 6 7] [1 2 3 4]
The function F can also take an argument from the stack. so this also works.
4 [1 2 3 4 5 6 7] [>] split& ??
=[5 6 7] [1 2 3 4]
Thus the split_on_first_element takes the first element of a list, and split that
list based on that element as a filter.
binrec
=======
binrec expects 4 arguments,
Arg1 is the terminating condition,
Arg2 is the result if the terminating condition is met.
Arg3 is an executable statement that returns two entities.
The entire binrec statement is performed on each of the
two entities until the terminating condition is met.
Arg4 is what to do with the result of the previous statement.
Algorithm.
Here, the small? checks if the list is empty or contains just one element.
if it is, then the result is arg2 - []
ie:
[] small? ??
=true
[1] small? ??
=true
[1 2 3 4] small? ??
=false
split_on_first_element takes is executed on all lists that are larger than size 1
and as explained above, splits them into two based on the first element.
on the resultent lists, the entire qsort is performed again due to binrec.
The last joinparts takes these elements (pivot list1 list2) which are present now
on the stack, and combines them to produce a single sorted list.
A slightly friendlier function (with out the binrec.)
[qsort
[joinparts [pivot [*list1] [*list2] : [*list1 pivot *list2]] view].
[split_on_first_element uncons [>] split&].
[small?]
[]
[split_on_first_element [list1 list2 : [list1 qsort list2 qsort joinparts]] view i]
ifte].
The binrec and friends are more powerful than the explicit recursion done above, but for people new to concatenative languages, this kind of recursion may look more intuitive.
Enhancements:
- The language has become relatively stable.
- Lots of bugfixes were made in scope handling.
- Tree operations were added.
- Generic combinators were moved out into a separate library.

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!

The Language Machine is a free software toolkit for language and grammar. It includes a shared library, a main program, and several metalanguage compilers with one frontend. The system is easy to use on its own or as a component.
The Language Machine directly implements unrestricted rule-based grammars with actions and external interfaces. A unique diagram shows rulesets in action.
Main features:
- rules describe how to recognise and transform grammatical input
- the left-side of a rule describes a pattern
- the right-side of a rule describes how the pattern is treated
- the left- and right- sides are unrestricted pattern generators
- the system is a kind of symbolic engine for grammar
- the metalanguage is very simple and very concise
- multiple grammars, rule priorities, left-recursion, right-recursion ...
- variables and associative arrays, a subset of javascript
- transformed representations can include actions and side-effects
- transformed representations can themselves be analysed as input
- can be used as a free-standing engine or as a shared library
- can be packaged together with precompiled rules
- very simple interface to external procedures in C and D languages
- built-in diagnostics with lm-diagram generator
- several self-hosted metalanguage compilers with a single front end
- compiled rules can be wrapped as shell scripts, or as C or D programs
- rules can be compiled to C or D code
- metalanguage source can be treated as wiki text in the Mediawiki format
Enhancements:
- modifications for compatibility with gdc-0.22 and dmd-1.010
- element.d - wrong indices to non-keyword array literal cells
- add src/dmd/Makefile for building with dmd compiler

Language::Zcode::Runtime::State is a Perl module to handle saving, restoring, etc. the game state.

restoring

Getter/setter: currently in the process of restoring or not?

start_machine

Start executing the Z-machine.

In the normal case (starting a new game, or restarting), this is as simple as calling the Z-machine subroutine whose address is stored in the header.
If were restoring from a save file, its more complicated. See "resume_execution".

z_call

Wrapper around Z-code subroutine calls. The main reason we need it is for save/restore.

In the normal case, z_call just calls the Z-code subroutine at address arg0 with the given args (arg5-argn), if any. Args 1-4 arent used by z_call, but (hack alert!) they go into the Perl call stack, which is needed for saving Z-machine state.

Input: subroutine address to call, local variables & eval stack (arrayrefs), next PC, store variable, args to the Z-sub.

See "The call stack" for far more detail on this sub and save/restore.

save_state

Implement the @save opcode, saving the current Z-machine state (as opposed to writing a table to a file, the other use of the @save opcode)

Note that this sub also gets called at the very end of the restoring process.

Returns 0 for failed save, 1 for successful save, 2 for "just finished restoring".

build_save_stack

Create a Z-machine call stack by peeking at the Perl call stack.

When calling Z_machine subroutines, we call z_call with all the information contained in a Z stack frame. We retrieve that information from the Perl call stack and build a Z-machine call stack with it.

restore_state

Implement the @restore opcode, restoring the current Z-machine state (as opposed to reading a table from a file, the other use of the @restore opcode)

Language::Zcode::Parser is a Perl module that reads and parses a Z-code file into a big Perl hash.

SYNOPSIS

# Create a Pure Perl Parser
my $pParser = new Language::Zcode::Parser "Perl";

# If they didnt put ".z5" at the end, find it anyway
$infile = $pParser->find_zfile($infile) || exit;

# Read in the file, store it in memory
$pParser->read_memory($infile);

# Parse header of the Z-file
$pParser->parse_header();

# Get the subroutines in the file (LZ::Parser::Routine objects)
my @subs = $pParser->find_subs($infile);

For finding where the subroutines start and end, you can either depend on an external call to txd, a 1992 C program available at ifarchive.org, or a pure Perl version.

Everything else is done in pure Perl.

new (class, how to find subs, args...)

This is a factory method. Called with Perl or TXD (or txd) as arguments, it will create Parsers of LZ::Parser::Perl or LZ::Parser::TXD, which are subclasses of LZ::Parser::Generic.

That class new method will be called with any other passed-in args.