Free java aot 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.

The Java Brainfuck Compiler is a compiler for the uniquely powerful Brainfuck language, which produces Java bytecode that will run on any Java Virtual Machine (with no intermediate steps such as going by way of Java code).

BNF for Java project is a parser/generator, or compiler-compiler. The parser reads your input text, or "terminals", specified by your BNF syntax.

The parser features indefinate look-ahead and back-track. As the grammar parses your file, it builds a parse-tree which carries the content in the structure of your grammar. Then the parse-tree is traversed, driving the output generators the you wrote in Java.

The compiler uses several files to control the project, so BNF for Java provides a Swing GUI to help you manage the BNF, Java, and XML files.

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.

Java::Import is Perl module to use Java classes in Perl.

SYNOPSIS

use Java::Import qw(
some.package.SomeClass
);

my $instance = new some.package.SomeClass();
$instance->someMethod();

my $ret_val = some::package::SomeClass::someStaticMethod();
$ret_val->someMethod();

$ret_val2 = $instance->someOtherMethod($ret_val);
$ret_val2->someMethod();

my $java_array_ref $instance->someMethod2();
foreach my $obj ( @$java_array_ref ) {
$obj->someMethod();
}

The purpose of this module is to provide a simple method for using Java classes from a Perl program while using the latest in Open Source Java Technology. Thus, this module makes great use of the GNU Compiler Tools for Java in its implimentation.

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.

Inline::Java lets you write Perl classes in Java and wrap/use existing Java classes. The project is an ILSM (Inline Language Support Module) for Java 2, and is part of the Inline family of modules.

Java::Build::JVM is a Perl module that starts one JVM for compiling.

SYNOPSIS

use Java::Build::JVM;

my $compiler = Java::Build::JVM->getCompiler();
$compiler->destination("some/path");

$compiler->classpath("some/pathto/jar.jar:some/other/path/javas");
$compiler->append_to_classpath("something/to/add/to/previous/path");

$compiler->compile([ qw(list.java of.java programs.java) ]);

This class starts a single JVM which it then helps you contact for compiling tasks. This is the most important feature of the popular Ant build tool. Using this class, you can effectively replace Ant, and its notoriously unmaintainable build.xml files, with Perl scripts. Most Ant tasks are already built in to Perl with far more flexibility than Ant provides.

To obtain a compiler, use this module, then call getCompiler. It has that name to prevent conflicts with the Java new keyword.

Once you have a compiler, you may change the destination of subsequent compiles from the location of the source files to a directory of your choice using the destination method. You can create or append to a classpath with the classpath or append_to_classpath methods. Note that your CLASSPATH environment variable still works in its usual way.

Finally, once you have the destination and classpath set, you can compile a list of files by passing them to the compile method. Note that they need to be in an array reference (if you dont know what that means, put the list in square brackets).

Note that you must have tools.jar in your CLASSPATH when you run your script. Without that, JVM.pm will not be able use Inline::Java. The classpath you use inside the script may be the same or different than your environment variable, depending on how you use the classpath and append_to_classpath methods.
Since Sun has, in its finite wisdom, chosen to deprecate the compiling methods that javac uses, there will be one warning for each time you call compile. It will say something like this:

Note: sun.tools.javac.Main has been deprecated.
1 warning

This warning is not a problem in Java 1.4.