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

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.

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).

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.

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 !

4tH is a Forth compiler with a little difference. Instead of the standard Forth engine it features a conventional compiler.
4tH is a very small compiler that can create bytecode, C-embeddable bytecode, standalone executables, but also works fine as a scripting language. It supports over 85% of the ANS Forth CORE wordset and features conditional compilation, pipes, files, assertions, forward declarations, recursion, include files, etc.
It comes with an RPN calculator, line editor, compiler, decompiler, C-source generators, and a virtual machine.
Enhancements:
- More CORE words and most of the DOUBLE wordset are supported.
- Output buffers can be flushed.
- An experimental multitasking environment was added.

PL/1 for GCC project is an attempt to create a native PL/I compiler using the GNU Compiler Collection. PL/I is a third-generation procedural language suitable for a wide range of applications including system software, graphics, simulation, text processing, Web, and business applications.
This is the eleventh code drop of the GCC front-end for the PL/I programming language.
PL/I for GCC is released under the terms of the GNU Public License; version 2. Version 0.0.11, includes a new infrastructure for the PL/I preprocessor.
It has been more than a year since the previous release of pl1gcc, but development has picked up again, so expect releases to happen more frequently. And remember you are always welcome to join the project, we need really help at all levels of development.
The v0.0.11 release marks another important step forward towards a fully functioning PL/I compiler: the preprocessor. The current implementation supports just a few statements, but thanks to the tools flex and bison, it is straight forward to add the missing preprocessor statements. Expect a few new ones to be added with each new release, just like the PL/I parser has been developed.
Currently there is still no codegeneration taking place, so dont run out and uninstall your production PL/I compiler, just yet.
But read ahead for some good news.
It would still be a great help for us if you try the compiler on some of your own source code, or if you could construct a PL/I program that really tests the corners of the grammar. Basically a program that does all what the syntax allows. As inspiration, have a look at the test program written by Paul Karagianis
http://www.multicians.org/proc-proc.html
but I am sure you can create a much worse PL/I program, which we would like to see. And if you release it under GPL it can be added to the pl1gcc hall of fame, so just go ahead and do the coding.
Please inform us about any syntax errors that might occur so we can check if the error is in the pl1gcc parser, and not in your code.
Installation:
Since the GCC PL/I is not yet part of mainline GCC, there are some manual steps you have to perform before you can use the GCC PL/I compiler.
If you are using Cygwin under Windows, please follow the instructions in the file INSTALL.cygwin. If you want to use eclipse please consult INSTALL.eclipse.
First you need the source code for the GCC compiler itself. If you do not already have the sourcecode installed you will have to download it.
This is how we did it; you can probably come up with another way.
Get latest working version of the gcc-core-4.2-2006mmdd weekly snapshot and
the latest version of the pl1gcc-0.0.x archive file, from http://pl1gcc.sourceforge.net
Note: The snapshot of gcc downloaded from the pl1gcc project is known to work with pl1gcc. If you try another snapshot from the GCC project, please let us know if it works or not.
GCC recommends to separate the source directories from the build directories, so create a direcory to hold the unpacked source code.
cd ~
mkdir gcc-src
Unpack the downloaded gcc-core-4.2-2006mmdd snapshot into your directory for gcc source, assuming the downloaded files are stored in ~/download, this will unpack the gcc compiler file:
cd ~/gcc-src
tar -xjf ~/download/gcc-core-4.2-2006mmdd.tar.bz2
Note: this will create a directory named ~/gcc-src/gcc-4.2-2006mmdd
Unpack the pl1gcc-0.0.x.zip file into your home directory, with these commands
cd ~
unzip ~/download/pl1gcc-0.0.x.zip
This will create the directories ~/pl1gcc-0.0.x/pl1
Create a link from ~/gcc-src/gcc-4.2-2006mmdd to your unpacked pl1 library:
cd ~/gcc-src/gcc-4.2-2006mmdd/gcc
ln -s ~/pl1gcc-0.0.x/pl1 pl1
Create an empty ~/gcc directory, where the built object will created:
cd ~
rm -rf ~/gcc
mkdir gcc
Unpacking is now done, and you can start to build your downloaded compiler. This might take a while (*).
Now do:
cd ~/gcc
../gcc-src/gcc-4.2-2006mmdd/configure
make
and go enjoy some of your favorite bewerages, and of course dont forget to make a donation to the pl1gcc project.
You can speed up the compilation considerably, by disabling some of the languages you do no longer need, now you have PL/I as your favorite compiler.
To do this edit the files ~/gcc-src/gcc-4.2-2006mmdd/ /config-lang.in,
and set the variable
build_by_default="no"
Enhancements:
- This release adds support for using the tilde character as the "not" operator and support for ENVIRONMENT().
- It adds location information to most messages. %INCLUDE can now have filenames inside of quotes.

MetaC language extends C in a 100% backward compatible way with reflective features and techniques for refactoring, reconfiguring and modifying arbitrary C source code.
Therefore, the extensions provide special metadata types for working with source code information, syntactical structures for the definiton of code templates, and metafunctions to gather information about source code and refactor, modify, delete, or insert code.
Some of the modifications that can be done with MetaC, are also realizable with the C preprocessor. But the C preprocessor suffers certain limitations that can be overcome using MetaC.
The area of applications for MetaC is not limited to specific domains. But its concepts and its motivation has been derived from problems of CASE tools for embedded real-time systems (e.g. Mathworks Matlab, Telelogics Tau, Aonixs STP).
- Source code reconfiguration and refactoring in general.
- Abstraction of APIs and hardware-specific or vendor-specific implementations of well-defined functionallity (ever got locked to a specfic API by a RTOS vendor?).
- Source code instrumentation for WCET-analysis
- Adaption of source code to multiple embedded targets (especially differing native platform APIs) based upon an abstract machine model
- Application specific debug support (e.g. control-flow or data-flow tracing)
- Verification of domain- and application-specific constraints (e.g. MISRAs rules set for C based programs in automotive applicaitons)
Advantages of the Metaprogramming Approach:
- Source code modification is done based upon syntax. In consequence invalid modifications can be detected at the moment they are executed.
- Decision for code modifications can be made upon user parameters and information derived from the source code
- Crosscutting reconfigurations (i.e. reconfigurations concerning multiple functions or modules) of source code are possible.
Enhancements:
- Support for Win32 hosts was added.
- Support for initializer lists was added.
- Some C99 issues were fixed.
- Several more enhancements were made.
- A whole bunch of bugs were fixed.