Free amsterdam compiler kit 6.0 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.

LLnextgen is an Extended-LL(1) parser generator. LLnextgen project is a rewrite of the LLgen parser generator by D. Grune and C.J.H. Jacobs which is part of the Amsterdam Compiler Kit (ACK).
Like all parser generators, LLnextgen takes the description of the grammar with associated actions as input, and generates a parser routine for use in compilers and other text processing programs.
LLgen, and therefore LLnextgen, extends on the LL(1) class of parser generators by allowing FIRST/FIRST conflicts and FIRST/FOLLOW conflicts to be resolved with both static and dynamic conditions.
Enhancements:
- This release adds a new operator for specifying an optional-final repetition.
- This is useful for implementing grammar rules like C99/C++ enums where a comma after the last constant is allowed, but not required.
- An option was added to change the extensions of the generated files.

Pre Make Kit (PMK) aims to be a BSD alternative to GNU autoconf, GNU libtool, and pkg-config. Pre Make Kit uses data files instead of scripts to limit the spreading of trojans in software packages.
Its designed to be easy to use for users and developers. For better portability and efficiency, all of the components are written in C. Requirements are a POSIX system, a C compiler, a POSIX shell, and a make tool.
Main features:
- Dependency configuration like autoconf (with partial compatibility mode).
- Compiler detection to set shared library flags.
- Architecture and cpu identification (support for x86 32 and 64 bits, IA64 and alpha).
- Internal pkg-config support (faster than calling pkg-config).
- Use a data file instead of a shell script that could hide trojans.

Now theres Java performance on Linux thats as fast as on Windows! IBM developerWorks has released IBMs latest Java port for Linux, the Java 1.1.8 Developer Kit for Linux. This new version, available for free, is a stable, high-performance implementation of Java on Linux.

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

Math::Symbolic::Compiler is a Perl module that can compile Math::Symbolic trees to Perl code.

SYNOPSIS

use Math::Symbolic::Compiler;

# A tree to compile
my $tree = Math::Symbolic->parse_from_string(a^2 + b * c * 2);

# The Math::Symbolic::Variable a will be evaluated to $_[1], etc.
my $vars = [qw(b a c)];

my ($closure, $code, $trees) =
Math::Symbolic::Compiler->compile($tree, $vars);

print $closure->(2, 3, 5); # (b, a, c)
# prints 29 (= 3^2 + 2 * 5 * 2)

# or:
($closure, $trees) =
Math::Symbolic::Compiler->compile_to_sub($tree, $vars);

($code, $trees) = Math::Symbolic::Compiler->compile_to_code($tree, $vars);

This module allows to compile Math::Symbolic trees to Perl code and/or anonymous subroutines whose arguments will be positionally mapped to the variables of the compiled Math::Symbolic tree.

The reason youd want to do this is that evaluating a Math::Symbolic tree to its numeric value is extremely slow. So is compiling, but once youve done all necessary symbolic calculations, you can take advantage of the speed gain of invoking a closure instead of evaluating a tree.

GMP compiler tool simplifies the use of GMP, the GNU multiple precision library. It scans a C source file for specially marked GMPS arithmetic expressions and replaces them with plain C.
The abbreviation gmpc stands for GMP compiler, or alternatively GMPS-to-C compiler. GMPS arithmetic expressions are straightforward infix expressions which transparently support the special types mpq_t, mpz_t and mpf_t as defined by GMP. GMPS means, rather unimaginatively, `GMP script.
No dependencies are added to the resulting C source, so there is no need to include additional header files or link with special libraries other than GMP.
Invoking gmpc
To translate a .gmpc file to C source, at least the input and output files must be given. The most concise invocation would look like this:
gmpc -o foo.c foo.gmpc
This will translate foo.gmpc into foo.c.
It is highly recommended to enable all warnings with the -Wall switch:
gmpc -Wall -o foo.gmpc foo.c
Other switches can be used to change the default behaviour of gmpc. They are listed in the following sections.
Enhancements:
- Added support for C-like compound assignments, increment and decrement operators.
- Fixed an assignment precedence bug.
- Temporary variables and constants are grouped together to make generated code more readable.
- Added Doxygen comments and configuration file.