Free java to exe compiler software for linux

JavaNativeCompiler (JNC) is a Java to native compiler. The project allows AOT (ahead of time) compilation of your Java applications. With JNC, you can create real standalone native binaries (.exe on Windows) which will no longer depend on a JRE.
This is especially useful when applications have to be deployed to end-users. All vexatious problems of deploying Java applications can be solved by compiling them to native. They will be:
- Easy to deploy
No JRE dependency. Most end-users dont know what they have installed.
No more problems on how to create an executable file out of a JAR or class file.
- Hard to decompile
Java can easily be decompiled. Native compilation will protect your source code.
- Run fast from the start
No more overhead for loading a JRE.
Enhancements:
- This release fixes a couple of problems with AWT/Swing and XML.
- It also once again contains a version for Linux.
- The compiler binary downloads are smaller.

Scriptol to Php Compiler is a scriptol program that may be interpreted by the Php interpreter and it may be also compiled either to C++ or directly as an executable.

The Php interpreter is required by solp (download it at www.php.net or get it on the Scriptol CD).

Installation:

It is better to install Scriptol at root of a disk, for example:
/home/user/scriptolp

Once the archive is extracted into the scriptolp directory, you have just to go to this directory from the console to run the compiler.

To use the compiler at command line from any directory, you have to put the compilers into the path, in the usr directory for exemple, or any directory assigned to the path variable (see .bashrc or equivalent). You may also add the scriptol directory to list of paths. Before to use the compiler, you have to read the licence, in the doc directory: licence.html.

Usage:

Type the source of your program in a text editor and save it as mysource.sol or any other name with the sol extension.

Then just type:

./solp mysource

To know the compilers options, type solp without argument, at command line.

Examples:

Type from the main scriptol directory:
./solp demos/helloyou

Scriptol to binary Compiler is a C++ native compiler.

Installation:

It is better to install Scriptol at root of a disk, for example:
c:scriptolc

Once the archive is extracted into the scriptolc directory, you have just to change to this directory to run the compiler.

To use the compiler at command line from any directory, you have to put the compiler into the path variable.

The setup script installs required file into sub-directories, or into the directory given as argument. Before to use the compiler, you have to read the licence, in the doc
directory: licence.html.

Usage:

Just type:
./solc mysource

Type "solc" only to list the options.

If your program is a multi-file project, the source given as parameter must be the main source file, the compiler will know dependencies from "include" statements and will build what is needed.

Exemples:

Type from the main scriptol directory:
./solc -bre demosfibo

Configuring:

By editing the solc.ini file, you may change the second pass compiler (you may have to rebuild the libsol library for this compiler), change the options of the compiler or add header files to include.

To add header files, just add "header=someheader.hpp" lines into the config file.

A xxx.cfg file may be written for each project main source beeing xxx, and if present, it overloads the solc.ini file.

Blatte::Compiler is a Perl module to compile a Blatte document into Perl.

SYNOPSIS

use Blatte::Compiler;

&Blatte::Compiler::compile($file_handle, &callback);

&Blatte::Compiler::compile_sparse($file_handle, &callback);

sub callback {
my($val, $src) = @_;

if (defined($src)) {
...Blatte expression...
} else {
...plain text...
}
}

This is a convenient interface for parsing a file full of Blatte code. A file handle and a callback are passed to compile() or compile_sparse() (see below for the difference between the two). The callback is then invoked for each top-level item parsed from the input.

The compile() function treats its entire input as a sequence of Blatte expressions, including plain text at the top level, which is divided up into Blatte "words," each of which is one Blatte expression. The callback is called once for each expression, with two arguments: the Perl string resulting from parsing the Blatte expression; and the Blatte source string itself.

The compile_sparse() function works the same way, except that plain text at the top-level of the input is not divided into words. Only Blatte expressions beginning with a Blatte metacharacter are parsed as described above. All text in between such expressions is passed as a single string to the callback, with no second argument.

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.

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.

ObjectBox is a free, opensource o:XML compiler and interpretor written entirely in Java. ObjectBox o:XML Compiler implements The o:XML Programming Language specification, and provides a complete compilation and runtime environment.
Main features:
- Java extensions - o:XML procedure that converts any Java class/object to an o:XML type for seamless language integration, making existing Java classes instantly available for instantiation and subtyping as any other o:XML type.
- Java Servlet support for deployment in J2EE environments.
- Caching of compiled programs allowing threadsafe concurrent execution.
- Commandline executable that passes arguments to o:XML program.
- Java Ant task for powerful content generation and integration in XML publishing systems.
Before compilation the program file is parsed and validated for well-formedness. The result of compiling a program is an object hierarchy of actions, that will produce the program result as a sequential output to either a DOM tree, output stream or a SAX content handler.
In order to obtain a complete and fully valid XML document, the program must terminate successfully. However all o:XML programs dont necessarily terminate - see the Fibonacci Series for an example of a program that generates an infinite, unbroken XML stream.
A compiled o:XML program contains all parsed o:Path expressions and XML-generating objects. It is thread-safe and can execute concurrently in different runtime environments, producing output to different result handlers. The program in its compiled form is independent of the XML file it was generated from as well as the physical form of its output.
Version restrictions:
- Access Specifiers (public/private/protected) not fully implemented
- Context Node probably not always correct
Enhancements:
- Integration with the Spring 2.0 framework.
- Allows for the creation of o:XML beans in Spring 2.0.
- Full integration with support for XML schema configuration, and the ability to mix and match beans: o:XML, Java, JRuby, Groovy, Beanshell, etc.

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.