Free java to native 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 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.

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.

Java + information flow (Jif in short) is a security-typed programming language that extends Java with support for information flow control and access control, both at compile time and at run time.

The source code for the Jif compiler and run-time system is now available for download. Jif is written in Java and is built using the Polyglot extensible Java compiler framework.

Static information flow control can protect the confidentiality and integrity of information manipulated by computing systems. The compiler tracks the correspondence between information the policies that restrict its use, enforcing security properties end-to-end within the system. After checking information flow within Jif programs, the Jif compiler translates them to Java programs and uses an ordinary Java compiler to produce secure executable programs.

Jif extends Java by adding labels that express restrictions on how information may be used. For example, the following variable declaration declares not only that the variable x is an int, but also that the information in x is governed by a security policy:

int {Alice→Bob} x;

In this case, the security policy says that the information in x is controlled by the principal Alice, and that Alice permits this information to be seen by the principal Bob. The policy {Alice←Bob} means that information is owned by Alice, and that Alice permits it to be affected by Bob. Based on label annotations like these, the Jif compiler analyzes information flows within programs, to determines whether they enforce the confidentiality and integrity of information.

Portable Object Compiler project consists of a set of Objective-C class libraries and a precompiler (translator) that generates plain C code.
Main features:
- Easy to install or to modify.
- Works on many systems with the native cc, debugger, profiler etc. (Unix, Windows, Macintosh, Beos, OpenVMS etc. see Platforms.txt file)
- Option for reference counted memory management (-refcnt). This uses the native malloc(), free() etc. but the compiler generates statements for keeping track of references (Tested on a few platforms, such as IRIX 5.2 with the SGI malloc).
- Built-in possibility of tracing Objective C messages. (OBJCRTMSG)
- Straightforward "C" messenger; "inline cache" messenger. Forwarding C messenger (to support -doesNotUnderstand:).
- All classes get a +initialize message at start-up, rather than each class receives a +initialize before it receives its first message.
- Some support for translating Objective-C to Smalltalk (-st80 option)
- Automatic archiver. Compiler generates code for classes to save and load objects to and from disk (for all instance variables of type "id").
- Option for Garbage Collection (using Boehm gc package). Tested on some UNIXes and WIN32. Option for reference counted memory management (doesnt require Boehm).
- Exception handling scheme (using Objective-C Blocks) that allows to specify a default handler to be executed.
- Supports dynamically loading Objective-C modules on Windows, FreeBSD, HP-UX, Linux, IRIX, Digital Unix etc.
- Has a switch for double indirection for Object identifiers (id as a handle instead of a pointer). (-become: method)
- Supports forwarding messages (-doesNotUnderstand: method)
- Support for Embedded SQL in Objective-C (Informix only for now)
- Great system for experimentation with your own additions/extensions to Objective C !

Mumps is a general purpose programming language that supports a native hierarchical data base facility. It is supported by a large user community (mainly biomedical), and a diversified installed application software base. The language originated in the mid-60s at the Massachusetts General Hospital and it became widely used in both clinical and commercial settings. A dwindling number of implementations exist for the language. There are both ANSI, ISO (ISO/IEC 11756:1992) and DOD approved standards for Mumps.

As originally conceived, Mumps differed from other mini-computer based languages of the late 1960s by providing: 1) an easily manipulated hierarchical (multi-dimensional) data base that was well suited to representing medical records; 2) flexible string handling support; and (3) multiple concurrent tasks in limited memory on very small machines. Syntactically, Mumps is based on an earlier language named JOSS and has an appearance that is similar to early versions of Basic that were also based on JOSS.

This translator implements much of the most recent Mumps standard (see the manual). Mumps programs are translated to standard C++ programs and subsequently compiled to binary executables. This distribution contains the compiler source code, the manual, the run-time functions source code, all written in C/C++, and examples, written in Mumps. Also included is a stand-alone Mumps Interpreter for Windows XP and Linux. Click here for additional details.

The MDH (Multi-Dimensional and Hierarchical Data Base Toolkit) is a Linux-based, open sourced, toolkit of portable software that supports very fast, flexible, multi-dimensional and hierarchical storage, retrieval and manipulation of data bases ranging in size up to 256 terabytes. The package is written in C and C++ and is available under the GNU GPL/LGPL licenses in source code form. You must install the Mumps Compiler in order to use the MDH.

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.

Java for C++ is a tool to generate C++-wrapper-classes for existing Java-classes. This tool reads a list of Java class names and creates source code for C++-classes to wrap them.
The implementation of the wrapper classes uses JNI (Java Native Interface) to call the "real" Java classes.
The C++-API to use these wrapper classes is very close to the API of the original Java classes. So developers of C++-software can use Java-classes as if they have been implemented in C++.
Enhancements:
- A problem where null values for method arguments, method return values, or field values caused some generated code to crash was fixed.
- Updating is strongly encouraged.