Free javascript compiler software for linux

Intel C++ Compiler application is a full fledged C/C++ compiler and debugger suite. Its aim is to provide outstanding performance for all Intel 32-bit and 64-bit processors, while not requiring the need for porting applications from other compilers.

It provides optimization technology, threaded application support, and features to take advantage of Hyper-Threading technology. It is substantially source and object code compatible with GNU C, providing fullest compatibility with GCC and G++ 3.x/4.x both in terms of code and of API. It is thereby also easy to integrate with existing development environments.

Aubit 4GL compiler is a project to make a free Informix-4GL compatible compiler. Aubit 4GL compiler translates 4GL source into executable programs, enabling fast creation of screen/form-based applications.

With support for SQL statements forming an intrinsic part of the language, its especially suitable for developing database-oriented applications. Database connectivity is provided for PostgreSQL, Informix, and ODBC. It supports both ncurses (console mode) and GTK+ (GUI mode) output.

Scheme2Js is a Scheme to Javascript compiler. While some effort has been spent on being as close as possible to R5rs, we concentrated mainly on efficiency.
Usually Scheme2Js produces Javascript code, that is comparable to hand-written code. In order to achieve this performance, Scheme2Js is not completely R5rs compliant. In particular it lacks support for continuations, exact numbers and it treats tail recursion only partially.
Scheme2Js provides several flags, that allow to modify the result:
- --no-js-dot-notation disallows access to JavaScript fields with the dot-notation. This flag disables accesses of the form x.y like in document.getElementById. It is however still possible to access the is a valid expression using the js-field function.
- --mutable-strings: in order to improve the performance of string-operations and to ease the interface between Scheme and JavaScript code, the default implementation maps Scheme strings to JavaScript strings. Contrary to Scheme strings, JavaScript strings are however immutable. This flag maps strings to a JavaScript class, that represents Scheme strings, that are mutable. The resulting code might be slightly slower, and it is more difficult to interface with Javascript code.
- --encapsulate-parts encapsulates the program into an anonymous function. Only global variables are outside of this anonymous function. On one hand this introduces one function call to the anonymous function. But on the other hand most Javascript implementations should run faster with this optimization: usually hashtables are used to represent scopes in JavaScript. By using an anonymous function the programs variables are separated into their own smaller hashtable which (in theory) accelerates accesses to these variables. More importantly the variables are stored in their own hashtable, and not in the global hashtable, which is accessible by the global variable. It is extremely easy to indirectly modify the contents of global variables. Inlining or other common optimizations are hence impossible to do on global variables. By storing the programs variables in an anonymous function these optimizations become again possible.
- --optimize-var-number reduces the number of variables used in the resulting JavaScript code. The code may run faster, but is more difficult to debug, as the variable names are lost and the same variable might be used several times.
- --optimize-while: with this flag Scheme2Js optimizes common while loops. The unoptimized while loops are often of the form:
while(true) {
if(test)
resVar = res;
else {
modify_loop_variable;
continue;
}
break;
}
This optimization looks for these patterns and moves the test into the while loop:
while(!test) {
modify_loop_variable;
}
resVar = res;
This optimization has been implemented only recently and is therefore not yet activated by default.
- --verbose prints some information.
- --no-inlining disables all function inlining (constants might still be inlined).
- --inline-globals lets Scheme2Js inline global functions and constants. This might have two unwanted side-effects: for one, global variables are often used to transfer data between different modules. Some inlined functions are lost if there is no reference to them anymore. If global functions are to be used outside a module, one should not use this flag. (This behavior is likely to change in future versions of Scheme2Js.)
- --unresolved-is-js: if a variable is unbound, the compiler will assume the variable comes from another module, or from JavaScript. See Section Scheme - Javascript for a more detailed discussion of the JavaScript Scheme interface.
- --js-this provides the this variable within Scheme functions. This way, Scheme procedures can be used as methods of JavaScript objects.
- --no-tailrec disables the tailrec to while-loop optimization. If you suspect a bug in the compilers way of translating tail-recs, you could try this flag.
- --no-optimize-calls disables Scheme2Js inlining of binary or unary operations. For instance sci_plus(3, 5) is optimized to (3+5). This optimization is quite important, and theres usually no reason to disable it.
- --no-optimize-consts disables the pre-constant calculation. Unless disabled (with this flag), compound constants are precalculated and their occurrences replaced by a reference to a variable holding the constant. This makes repeated accesses to these constants faster, but introduces new variables.
- --no-optimize-boolify disables the boolify optimization. JavaScripts and Schemes boolify are not equivalent: JavaScript considers false, 0, null and undefined to be false, whereas Scheme only has #f. The unoptimized boolify therefore always adds the test against false: if (test !== false) ... If Scheme2Js can see, that the test itself is a boolean, it can remove the unnecessary !== false test. This flag disables this optimization.
- --d STAGE prints a dot-file (see graphviz) of the AST after stage STAGE. Possible stages are: expand, tree, symbol, node-elim1, tail, inline, constant-propagation, rm-unused-vars, capture, node-elim2, while, (tt "statements"), node-elim3. Usually one doesnt need this flag, unless for debugging purposes.
- --print-locs prints the original locations as comments to the JavaScript file. These locations are currently the character-offset from the beginning of the file.
Enhancements:
- This release adds trampolines.

State Machine Compiler takes a state machine stored in an .sm file and generates the state pattern classes in nine programming languages.
Its features include default transitions, transition arguments, transition guards, push/pop transitions, and Entry/Exit actions. State Machine Compiler requires Java SE 1.4.1 or better.
Enhancements:
- This release cleans up C# and VB.net debug output using System.Diagnostics.Trace.
- It fixes a number of minor bugs.

Kent Retargettable Occam Compiler is a multi-platform Occam 2.1 compiler that is designed to allow the Occam programming language to be used on non-Transputer platforms.
KRoC, the Kent Retargettable occam-pi Compiler, is a collection of programs/libraries which facilitates the execution of occam-pi programs on various platforms. The version on this page is only for i386 compatible processors running Linux (although it has been reported to work on FreeBSD systems too). The main components are:
- occ21, the Inmos occam compiler
- tranx86, a translator from extended transputer code (ETC) to intel i386 object code
- CCSP, the run-time kernel, providing the virtual transputer
Enhancements:
- The occSDL library has been added. Documentation errors have been fixed.
- There are minor bugfixes to the compiler, wrappers, and examples.
- New examples have been added, including the classic Adventure Game and Space Invaders.

FreeBASIC - as the name suggests - is a free, open-source, 32-bit, MS-QuickBASICs syntax-compatible compiler, that adds new features such as pointers, unsigned data types, inline-assembly and many others.
Main features:
- syntax compatible with Microsofts QBASIC/QuickBASIC/PDS/VBDOS interpreters/compilers
- clean syntax
- great number of variables types, like BYTE/SHORT/INTEGER, SINGLE/DOUBLE and STRING
- user defined types (UDTs)
- enums (Enumerations)
- arrays
- pointers
- optional function arguments (numeric only)
- inline assembly
- pre-processor
- creates OBJs, LIBs, DLLs/Shared Libs, console and GUI EXEs
- as a 32-bit application
- optimized code generation
- completely *FREE*
- portability

XML::Filter::Dispatcher::Compiler can compile rulesets in to code.

SYNOPSIS

use XML::Filter::Dispatcher::Compiler qw( xinline );

my $c = XML::Filter::Dispatcher::Compiler->new( ... )

my $code = $c->compile(
Package => "My::Filter",
Rules => [
a/b/c => xinline q{warn "found a/b/c"},
],
Output => "lib/My/Filter.pm", ## optional
);

Most of the options from XML::Filter::Dispatcher are accepted.

NOTE: you cannot pass code references to compile() if you want to write the $code to disk, they will not survive. If you want to eval $code, this is ok.

METHODS

xinline

Hints to X::F::D that the string is inlinable code. This is a requirement when using the compiler and is so far (v.52) ignored elswhere. In xinlined code, $self refers to the current dispatcher and $e refers to the current events data. Or you can get that yourself in $_[0] and $_[1] as in a normal SAX event handling method.

compile

Accepts options that extend and override any previously set for the duration of the compile(), including the ruleset to compile.

GMP compiler tool simplifies the use of GMP, the GNU multiple precision library. It scans a C source file for specially marked GMPS arithmetic expressions and replaces them with plain C.
The abbreviation gmpc stands for GMP compiler, or alternatively GMPS-to-C compiler. GMPS arithmetic expressions are straightforward infix expressions which transparently support the special types mpq_t, mpz_t and mpf_t as defined by GMP. GMPS means, rather unimaginatively, `GMP script.
No dependencies are added to the resulting C source, so there is no need to include additional header files or link with special libraries other than GMP.
Invoking gmpc
To translate a .gmpc file to C source, at least the input and output files must be given. The most concise invocation would look like this:
gmpc -o foo.c foo.gmpc
This will translate foo.gmpc into foo.c.
It is highly recommended to enable all warnings with the -Wall switch:
gmpc -Wall -o foo.gmpc foo.c
Other switches can be used to change the default behaviour of gmpc. They are listed in the following sections.
Enhancements:
- Added support for C-like compound assignments, increment and decrement operators.
- Fixed an assignment precedence bug.
- Temporary variables and constants are grouped together to make generated code more readable.
- Added Doxygen comments and configuration file.