Free retargetable compiler software for linux

The Amsterdam Compiler Kit or in short just ACK, is a fast, lightweight and retargetable compiler suite and toolchain written by Andrew Tanenbaum and Ceriel Jacobs, and was Minix native toolchain. The ACK was originally closed-source software (that allowed binaries to be distributed for Minix as a special case), but in April 2003 it was released under a BSD open source license.
The ACK achieves maximum portability by using an intermediate byte-code language called EM. Each language front-end produces EM object files, which are then processed through a number of generic optimisers before being translated by a back-end into native machine code.
Unlike gccs intermediate language, EM is a real programming language and could be implemented in hardware; a number of the language front-ends have libraries implemented in EM assembly. EM is a relatively high-level stack-based machine, and one of the tools supplied with ACK is an interpreter capable of executing EM binaries directly, with a high degree of safety checking. See the em document referenced below for more information.
ACK comes with a generic linker and librarian capable of manipulating files in the ACKs own a.out-based format; it will work on files containing EM code as well as native machine code. (You can not, however, link EM code to native machine code without translating the EM binary first.)
Installation:
To install the ACK, you need to download the source package and compile it.
Version 5.6 compiles cleanly on Linux, but it has had little testing so far. The installation instructions are complex but straightforward provided you follow the instructions. Please read the README; it provides a detailed walk-through of the compilation process, telling you what to type at each stage.
Enhancements:
- Support has been added for generating CP/M binaries using the 8080 code generator.
- The various optimisers have been beaten into shape, and its now possible to use them on all platforms; a basic peephole optimiser has been set up for the 8080.
- The floating point system has been confirmed working on the pc86 and linux386 platforms.
- ANSI compatibility has been improved, binary sizes have been reduced, and there are many bugfixes everywhere.

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

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

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

Obfuscated Tiny C Compiler (OTCC) is a very small C compiler I wrote in order to win the International Obfuscated C Code Contest (IOCCC) in 2002.

My goal was to write the smallest C compiler which is able to compile itself. I choose a subset of C which was general enough to write a small C compiler. Then I extended the C subset until I reached the maximum size authorized by the contest: 2048 bytes of C source excluding the ;, {, } and space characters.

I choose to generate i386 code. The original OTCC code could only run on i386 Linux because it relied on endianness and unaligned access. It generated the program in memory and launched it directly. External symbols were resolved with dlsym().

In order to have a portable version of OTCC, I made a variant called OTCCELF. It is only a little larger than OTCC, but it generates directly a dynamically linked i386 ELF executable from a C source without relying on any binutils tools! OTCCELF was tested succesfully on i386 Linux and on Sparc Solaris.

NOTE: My other project TinyCC which is a fully featured ISOC99 C compiler was written by starting from the source code of OTCC !

Compilation:

gcc -O2 otcc.c -o otcc -ldl
gcc -O2 otccelf.c -o otccelf

Self-compilation:

./otccelf otccelf.c otccelf1