Free multi language translator 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.

SNMP Trap Translator is an SNMP trap handler written in Perl for use with the NET-SNMP and UCD-SNMP snmptrapd program. Received traps are translated into friendly messages using variable substitution.
Output can be to STDOUT, text log file, syslog, NT Event Log, MySQL (Linux/Windows), PostgreSQL, or an ODBC database. User defined programs can also be executed.
Many network devices including but not limited to network switches, routers, remote access servers, UPSs, printers and operating systems such as Unix and Windows NT have the ability to send notifications to an SNMP manager running on a network management station. The notifications can be either SNMP Traps, or SNMP Inform messages.
The notification can contain a wide array of information such as port failures, link failures, access violations, power outages, paper jams, hard drive failures etc. The MIB (Management Information Base) available from the vendor determines the notifications supported by each device.
The MIB file contains TRAP-TYPE (SMIv1) or NOTIFICATION-TYPE (SMIv2) definitions, which define the variables that are passed to the management station when a particular event occurs.
Enhancements:
- Various database improvements have been added such as support for proper date/time data types, statistics logging, and custom columns.
- The formatting for unknown_trap_exec can now be changed.
- Support has been added to MATCH for bitwise AND.
- A new log file has been added for logging system messages to a text file for users without access to syslog.
- Various bugs have been fixed, including support for Net-SNMP 5.4 traphandle, a daemon mode PID file, REGEX captures, MATCH modifiers, and others.

GNOME Translate is a GNOME interface to libtranslate. It can translate a text or web page between several natural languages, and it can automatically detect the source language as you type.

GNOME Translate is free software, released under the terms of the GNU General Public License.

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.

The Mozilla Afrikaans Language Pack provides translations of the Mozilla suites Web browser, email program, and editor into Afrikaans.

All functions, errors, menus, and buttons are translated into Afrikaans.

A free IDL (Interactive Data Language) compatible incremental compiler (ie. runs IDL programs). IDL is a registered trademark of Research Systems Inc.
Full syntax compatibility with IDL 6.0
ALL IDL language elements are supported, including:
- Objects,
- Pointers,
- Structs,
- Arrays,
- System variables,
- Common blocks,
- Assoc variables,
- All operators,
- All datatypes,
- _EXTRA, _STRICT_EXTRA and _REF_EXTRA keywords...
The file input output system is fully implemented
(Exception: For formatted I/O the C() sub-codes are not supported yet)
netCDF files are fully supported.
HDF files are partially supported.
Basic support for HDF5 files.
Overall more than 240 library routines are implemented. For a sorted list enter HELP,/LIB at the command prompt and look for library routines written in GDL in the src/pro subdirectory.
The WRITEFITS procedure and the READFITS function from the IDL Astronomy Users Library compile and run under GDL.
Graphical output is partially implemented. The PLOT, OPLOT, PLOTS, XYOUTS and TV commands (along with WINDOW, WDELETE, SET_PLOT, WSET, TVLCT) work (important keywords, some !P system variable tags and multi-plots are supported) for X windows and postscript output.
GDL has an interface to python.
No GUI support (widgets) is implemented so far.
GDL is free software licensed under the GPL

Arena Scripting Language is a light-weight scripting language. The language uses a syntax and library similar to that of ANSI C, but adds automatic memory management and runtime polymorphism on top of that.
Main features:
- syntax similar to ANSI C
- standard library similar to ANSI C
- automatic memory management
- runtime polymorphism
- support for exceptions
- support for anonymous functions
Enhancements:
- This release changes the system() library function to return the raw exit status as given by the operating system.

SQL::Translator::Manual is a Perl module that contains a manual for SQL translator.

SYNOPSIS

SQL::Translator (AKA "SQLFairy") is a collection of modules for transforming (mainly) SQL DDL files into a variety of other formats, including other SQL dialects, documentation, images, and code. In this manual, we will attempt to address how to use SQLFairy for common tasks. For a lower-level discussion of how the code works, please read the documentation for SQL::Translator.

It may prove helpful to have a general understanding of the SQLFairy code before continuing. The code can be broken into three conceptual groupings:

Parsers
The parsers are responsible for reading the input files and describing them to the Schema object middleware.

Producers
The producers create the output as described by the Schema middleware.

Schema objects
The Schema objects bridge the communication between the Parsers and Producers by representing any parsed file through a standard set of generic objects to represent concepts like Tables, Fields (columns), Indices, Constraints, etc.

Its not necessary to understand how to write or manipulate any of these for most common tasks, but you should aware of the concepts as they will be referenced later in this document.