Free native compiler software for linux

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

Pod::Compiler can compile POD into an object tree.

This package, based on Pod::Parser, compiles a given POD document into an object tree (based on Tree::DAG_Node). It prints errors and warnings about the POD it reads. The result can be used to conveniently convert the POD into any other format.

The resulting objects have a variety of methods to ease the subsequent conversion.

There are two script based on this package, namely podchecker2, an enhanced POD syntax checker and podlint, which beautifies the POD of a given file.

This package is object-oriented, which means that you can quite easily build a derived package and override some methods in case the given behaviour does not exactly suit your needs.

Package Functions

The following functions can be imported and called from a script, e.g. like this:

use Pod::Compiler qw(pod_compile);
my $root = pod_compile(myfile.pod);

pod_compile( { %options } , $file )
pod_compile( $file )

Compile the given $file using some %options and return the root of the object tree representing the POD in $file. The return value is either undef if some fatal error occured or an object of type Pod::root. See below for methods applicable to this class and for the options.

The special option -compiler => class lets you specify an alternate (derived) compiler class rather than Pod::Compiler.

Compiler Object Interface

The following section describes the OO interface of Pod::Compiler.

$c = Pod::Compiler->new( %options )

Set up a new compiler object. Options (see below) can be passed as a hash, e.g.

$c = Pod::Compiler->new( -warnings => 0 ); # dont be silly

Pod::Compiler inherits from Pod::Parser. See Pod::Parser for additional methods.

$c->initialize()

Initalize, set defaults. The following options are set to the given defaults unless they have been defined at object creation:

-errors => 1

Print POD syntax errors (using messagehandler) if option value is true.

-warnings => 1

Print POD syntax warnings (using messagehandler) if option value is true.

-idlength => 20

Pod::Compiler creates a unique node id for each =head, =item and X, consisting only of w characters. The option value specifies how many characters from the original node text are used for the node id by the built-in make_unique_node_id method. See below for more information.

-ignore => BCFS

This option specifies which interior sequences (e.g. B< ... >) are ignored when nested in itself, e.g. B< ...B< ... >... >. The inner B is simply discarded if the corresponding letter appears in the option value string.

-unwrap => I

This option specifies which interior sequences (e.g. I< ... >) are unwrapped when nested in itself, e.g. I< ...I< ... >... > is turned into I< ... >...I< ... >. While some destination formats may handle such nestings appropriately, other might have problems. This option solves it right away. By the way, from a typographical point of view, italics are often used for emphasis. In order to emphasize something within an emphasis, one reverts to the non-italic font.

name =>

This is used to store the (logical) name of the POD, i.e. for example the module name as it appears in use module;. It is used internally only to detect internal links pointing to the explicit page name. Example: You compile the file Compiler.pm which contains the package Pod::Compiler. You set name to Pod::Compiler (there is no safe automatic way to do so). Thus if the file includes a link like L< Pod::Compiler/messagehandler > it is recognized as an internal link and it is checked whether it resolves. Of course you should have written the link as L< /messagehandler >...

-perlcode => 0

If set to true, the compiler will also return the Perl code blocks as objects Pod::perlcode, rather than only the POD embedded in the file. This is used e.g. by podlint.

$c->option( $name , $value )

Get or set the compile option (see above) given by $name. If $value is defined, the option is set to this value. The resulting (or unchanged) value is returned.

$c->messagehandler( $severity , $message )

This method is called every time a warning or error occurs. $severity is one of ERROR or WARNING, $message is a one-line string. The built-in method simply does

warn "$severity: $messagen";
$c->name( [ $name ] )

Set/retrieve the name property, i.e. the canonical Pod name (e.g. Pod::HTML). See above for more details.

$c->root()

Return the root element (instance of class Pod::root) representing the compiled POD document. See below for more info about its methods.

$c->make_unique_node_id($string)

Turn given text string into a document unique node id. Can be overridden to adapt this to specific formatter needs. Basically this method takes a string and must return something (more or less dependent on the string) that is unique for this POD document. The built-in method maps all consecutive non-word characters and underlines to a single underline and truncates the result to -idlength (see options above). If the result already exists, a suffix _n is appended, where n is a number starting with 1. A different method could e.g. just return ascending numbers, but if you think of HTML output, a node id that resembles the text and has a fair chance to remain constant over subsequent compiles of the same document gives the opportunity to link to such anchors from external documents.

Steel Bank Common Lisp is a development environment for Common Lisp, with excellent support for the ANSI standard: garbage collection, lexical closures, powerful macros, strong dynamic typing, incremental compilation, and the famous Common Lisp Object System (multimethods and all).

Steel Bank Common Lisp also includes many extensions, such as native threads, socket support, a statistical profiler, programmable streams, and more. These are all available through an integrated, interactive native compiler which feels like an interpreter.

SBCL is unique in being a multiplatform native compiler which bootstraps itself completely from source, using a C compiler and any other ANSI Common Lisp implementation.

Whats New in This Release:

* enhancement: experimental macro SB-EXT:COMPARE-AND-SWAP provides
atomic compare-and-swap operations on threaded platforms.
* enhancement: experimental function SB-EXT:RESTRICT-COMPILER-POLICY
allows assining a global minimum value to optimization qualities
(overriding proclamations and declarations).
* enhancement: closed over variables can be stack-allocated on x86
and x86-64.
* performance bug fix: GETHASH and (SETF GETHASH) are once again
non-consing.
* optimization: slot definition lookup is now O(1). This speeds up
eg. SLOT-VALUE and (SETF SLOT-VALUE) with variable slot names.
* optimization: STRING-TO-OCTETS is now up to 60% faster for UTF-8.
* optimization: ASSOC and MEMBER can now be open-coded for all
combinations of keyword arguments when second argument is constant
and SPEED >= SPACE. In other cases a specialized version is
selected.
* bug fix: using obsoleted structure instances with TYPEP and
generic functions now signals a sensible error.
* bug fix: threads waiting on GET-FOREGROUND can be interrupted.
(reported by Kristoffer Kvello)
* bug fix: backtrace construction is now more careful when making
lisp-objects from pointers on the stack, to avoid creating bogus
objects that can be seen by the GC.
* bug fix: defaulting of values in contexts expecting more than 7
variables now works on x86-64. (reported by Christopher Laux)
* bug fix: modifications to packages (INTERN, EXPORT, etc) are now
thread safe.
* bug fix: (SETF SYMBOL-PLIST) no longer allows assigning a non-list
as the property-list of a symbol.
* bug fix: DEFMETHOD forms with CALL-NEXT-METHOD in the method body,
in EVAL-WHEN forms with both :COMPILE-TOPLEVEL and :LOAD-TOPLEVEL
situations requested, are once again file-compileable. (reported
by Sascha Wilde)

Roadsend Compiler for PHP produces optimized stand alone applications, GUI applications (with GTK), libraries, and web applications from standard PHP source code.
The compiler produces native machine code, not PHP byte code, therefore interpreter is required.
Main features:
- does not require an interpreter
- compile entire source tree to one executable
- allows you to distribute easily
- once compiled, irreversible to original PHP source code
- automatically deploy finished project to a directory (included supporting libraries), ready for packaging
- examines your code as you type
- early syntax error recognition
- auto method and property completion
- auto parameter help
- code browser
- syntax highlighting programmers editor
- project source file manager
- compile and interpret projects (including GUI apps) from within IDE
- Uses GTK library for cross platform operability
- Compatible with PHP-GTK API
- Personal Edition for Windows only, Professional/Enterprise for Windows/Linux/FreeBSD
- create dynamic shared reusable libraries (.so / .dll)
- multiple applications can share same libraries
- support multiple library versions
- support for static libraries
- libraries usable by stand-alone, web, and interpreted applications
- run compiled code directly from Apache
- web server code is secure from unauthorized view
- simplify website application distribution and backup
- Personal edition include basic Apache module for Windows
- Professional/Enterprise editions include high performance Apache module for Unix
- execute PHP directly from source code without compiling
- save time during development
- allows you to debug easily
- distribute library to clients without requiring them to compile
- integrate existing PHP code with compiled code
- access compiled library directly from the command line
- runtime and extension API are compatible with Open Source PHP 4.3.x
- GTK applications are compatible with PHP-GTK API
- includes Standard, MySQL, PCRE, XML, and Posix extensions
- sell or give away unlimited, untimed copies of your compiled application
- built-in source level profiler helps you optimize your code
Requierments:
- GNU LIBC (GLIBC) >= 2.2
- GNU C Compiler (gcc) >= 2.95
- GNU LD linker (ld)
- MySQL 4.0.x
- PCRE >= 4.1
- libxml2 >= 2.6.3
- Apache 1.3.x
Enhancements:
- This version was ported to PHP5.
- Database access has switched from PEAR to PDO.
- A script is included to help port existing projects.

Objective Modula-2 programming language is a hybrid between Smalltalk and Modula-2 based on the object model and runtime of Objective-C.

The design is an example how native Cocoa/GNUstep support can be added to static imperative programming languages without implementing a bridge.

The projects scope encompasses the design of the Objective Modula-2 programming language and the implementation of a compiler to implement it. The initial compiler will generate Objective-C source code.

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.