Free scheme native code compiler software for linux

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

Ragel State Machine Compiler compiles finite state machines from regular languages into executable C/C++/Objective-C code. Ragel state machines can not only recognize byte sequences as regular expression machines do, but can also execute code at arbitrary points in the recognition of a regular language.
Ragel can also be thought of as a finite state transducer compiler where output symbols represent blocks of code that get executed instead of written to the output stream.
When you wish to write down a regular language you start with some simple regular language and build a bigger one using the regular language operators union, concatenation, kleene star, intersection and subtraction.
This is precisely the way you describe to Ragel how to compile your finite state machines. Ragel also understands operators that embed actions into machines and operators that control any non-determinism in machines.
Ragel FSMs are closed under all of Ragels regular language, action specification and priority assignment operators. This property allows arbitrary regular languages to be described. Complexity is limited only by available processing resources.
For example, you can make one machine that picks out specially formatted comments in C code, another machine that builds a list all function declarations and a third that identifies string constants then "or" them all together to make a single machine that performs all of these tasks concurrently and independently on one pass of the input.
Main features:
- Describe arbitrary state machines using regular language operators and/or state tables.
- NFA to DFA conversion.
- Hopcrofts state minimization.
- Embed any number of actions into machines at arbitrary places.
- Control non-determinism using priorities on transitions.
- Visualize output with Graphviz.
- Use byte, double byte or word sized alphabets.
- Generate C/C++/Objective-C code with no dependencies.
- Choose from table or control flow driven output.
Enhancements:
- The documentation and the Ruby code generator were improved.

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 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 Glasgow Haskell Compiler is a state-of-the-art, open source, compiler and interactive environment for the functional language Haskell.
Main features:
- GHC supports the entire Haskell 98 language plus a wide variety of extensions.
- GHC works on several platforms including Windows and most varieties of Unix, and several different processor architectures. There are detailed instructions for porting GHC to a new platform.
- GHC has extensive optimisation capabilities, including inter-module optimisation.
- GHC compiles Haskell code either by using an intermediate C compiler (GCC), or by generating native code on some platforms. The interactive environment compiles Haskell to bytecode, and supports execution of mixed bytecode/compiled programs.
- Profiling is supported, both by time/allocation and various kinds of heap profiling.
- GHC comes with a wide range of libraries.
GHC is heavily dependent on its users and contributors. Please come and join the mailing lists and send us your comments, suggestions, bug reports and contributions!
Enhancements:
- SMP support and impredicative polymorphism were added.
- The libraries were split into core and extra.
- Many more changes were made.

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.

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 !

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.