Semantic search

Jump to: navigation, search
Search

Edit query Show embed code

The query [[Software-development::compiler]] was answered by the SMWSQLStore3 in 0.0106 seconds.


Results 11 – 83    (Previous 500 | Next 500)   (20 | 50 | 100 | 250 | 500)   (JSON | CSV | RSS | RDF)


Ccache
'Ccache' is a fast compiler cache. It acts as a caching pre-processor to C/C++ compilers, using the -E compiler switch and a hash to detect when a compilation can be satisfied from cache. When the same code is compiled again the cached output is used, giving a significant speedup (typically 5x). You can also create symbolic links from your compiler's name to ccache; this lets you use ccache without any changes to your build system. 'Ccache' produces the same output that the real compiler would, including the same object files and compiler warnings that the real compiler would produce. The only way to tell you are using ccache is the speed.
Chicken
CHICKEN is a simple Scheme-to-C compiler supporting the language features as defined in the 'Revised^5 Report on Scheme'. It supports full tail-recursion and first-class continuations. The code it generates is quite portable; compiled files generated by it (including itself) should work with either no or minor changes on other systems. Linking to C modules and C library functions is straightforward, and compiled programs can easily be embedded into existing C code. The package includes many extra libraries.
Cim Heckert gnu.tiny.png
GNU cim offers a class concept, separate compilation with full type checking, interface to external C routines, an application package for process simulation and a coroutine concept. The portability of the GNU Simula Compiler is based on the C programming language. The compiler and the run-time system is written in C, and the compiler produces C code, that is passed to a C compiler for further processing towards machine code.
Clisp Heckert gnu.tiny.png
ANSI Common Lisp is a high-level, general-purpose programming language. GNU CLISP is a Common Lisp implementation by Bruno Haible of Karlsruhe University and Michael Stoll of Munich University, both in Germany. It mostly supports the Lisp described in the ANSI Common Lisp standard. It runs on most GNU and Unix systems (GNU/Linux, GNU/Hurd, FreeBSD, NetBSD, OpenBSD, Solaris, Tru64, HP-UX, BeOS, IRIX, AIX, Mac OS X and others) and on other systems and needs only 4 MB of RAM. The user interface comes in English, German, French, Spanish, Dutch, Russian and Danish, and can be changed during run time. GNU CLISP includes an interpreter, a compiler, a debugger, CLOS, MOP, a foreign language interface, a socket interface, i18n, fast bignums, arbitrary precision floats and more. An X11 interface is available through CLX, Garnet, CLUE/CLIO. GNU CLISP runs Maxima, ACL2 and many other Common Lisp packages.
Cloudgizer
Cloudgizer is a tool for building web applications as Apache modules in C language enhanced with simple markup, with emphasis on performance, small-footprint, and more productive and safer programming in C. It combines the ease of scripting with the power of C, improving the resource utilization for cloud applications. The programmer writes simple markup language mixed with C code, which is then translated entirely into C code and compiled natively as Apache module. The resulting application is fast and takes less memory, as there are no interpreters or virtual machines. Features include easy markups to use MariaDB database, HTML input parameters, cookies, simpler outputting of web pages, files storage and manipulation, encryption, encoding, program execution, web calls, safer and easier string manipulation etc. - the list is too long to place in one sentence. Overall Cloudgizer does a lot of stuff for you that you'd otherwise need to do yourself. A memory garbage collection system and memory overwrite/underwrite detection comes in handy for program stability. The same goes for string and memory handling markups to help write applications that won't crash. Also included is an application packaging system and an automated application installer. This makes rollout of products and release cycle more manageable. Cloudgizer source files have extension .v. Cloudgizer pre-compiler (cld program) will turn your .v files into .c files, ready for compilation as pure C programs. Then, your program will be compiled and linked with Apache web server on RH/Centos systems. It links with Apache as an Apache module in a "prefork" configuration. It does the work of communicating with Apache, and it makes it easier to write high-performance/small-footprint web programs in C. Cloudgizer is not designed to be thread-safe as it works in a "prefork" configuration of Apache. You can also build command-line programs. The same program can serve as both command-line utility and a web program linked with Apache. Cloudgizer works with RedHat/Centos 7 operating system, Apache web server and mariaDB database.
Compilercache
'Compilercache' is a wrapperscript around your C and C++ compilers. Each time you compile something, it puts the result into a cache. If you compile the same thing again, the result will be picked from the cache instead of being recompiled. The same applies if you change your compiler options: the old compilation is picked up from the cache, which speeds things up considerably. No Makefiles, no cleaning up dependencies, and no recompilation if you switch compiler options. Additionally, if you download an updated version of a package already on your system and compile it using compilercache, only the changed sources will be recompiled.
Cpphs
'cpphs' is a simplified Haskell re-implementation of cpp, the C pre-processor, in Haskell. The C pre-processor is widely used in Haskell source code, but a true cpp is not often available on some systems, and the common cpp provided by the gcc 3.x series is changing in ways that are incompatible with Haskell's syntax. This includes problems with, for instance, string gaps, and prime characters in identifiers. This project attempts to provide an alternative to cpp that is more compatible with Haskell and can be distributed with compilers.
Distcc
'distcc' distributes compilation of C or C++ code across several machines on a network. It should always generate the same results as a local compile, is simple to install and use, and is often significantly faster than a local compile. 'distcc' does not require all machines to share a filesystem, have synchronized clocks, or to have the same libraries or header files installed. Machines can be running different operating systems, as long as they have compatible binary formats or cross-compilers. 'distcc' sends the complete preprocessed source code across the network for each job, so all it requires of the volunteer machines is that they be running the distccd daemon, and that they have an appropriate compiler installed.
Dparser
'DParser' is a scannerless GLR parser generator based on the Tomita algorithm. It is self-hosted and very easy to use. Grammars are written in a natural style of EBNF and regular expressions and support both speculative and final actions.
Eli
Eli is a domain-specific programming environment formed by combining a collection of tools that implement powerful compiler construction strategies. In this environment, you can automatically generate complete language implementations from application-oriented specifications. Implementations can be either interpretive and used to invoke the operations of an existing system, or involve translation into an arbitrary target language. Eli has been used to produce translators, program generators, analysers, and interpreters. The user describes the problems that must besolved, and Eli automatically employs the tools and components needed for particular problem.
Emacs Common Lisp
Emacs Common Lisp is an implementation of Common Lisp, written in Emacs Lisp. The implementation provides a Common Lisp environment, separate from Emacs Lisp, running in Emacs. It does not intend to extend Emacs Lisp with Common Lisp functionality; however, Emacs Lisp functions can call Common Lisp functions and vice versa.
F2c
Fortran 77 compiler based on the original Unix f77 compiler, with the backend replaced by a C code generator.
Free Oberon
Free Oberon is a cross-platform IDE for development in Oberon programming language made in the classical FreePascal-like pseudo-graphic style. Compilation of user-written programs is performed using the Vishap Oberon Compiler and then GCC. The compiled console programs can be run in the built-in terminal emulator.
Freebasic
FreeBASIC is a compiler for the FreeBASIC programming language, a dialect of BASIC which is partially compatible with Microsoft QuickBASIC. It makes use of the GNU binutils and can compile itself.
Freepascal
FreePascal (aka FPK Pascal) is a 32 and 64 bit bit Pascal compiler with extensions for different processors and operating systems. It tries to stay compatible with the dialects of well known proprietary Pascal-based compilers, so you don't have to learn much to switch to free software and/or systems. The language syntax is semantically compatible with TP 7.0 as well as most versions of Delphi (classes, rtti, exceptions, ansistrings). FreePascal supports function overloading, operator overloading and other such features. It also comes with several command-line tools to help your programming, including a source formatter, a makefile generator, a C header translator, a unit dependency lister and even TP lex and yacc. FreePascal comes with its own development environment (not for all platforms yet).
Frost
Frost is a compiler wrapper which makes it possible to use functions with virtual arguments and multi methods in C++ programs as if they were a native feature.
G++
g++ is the traditional nickname of GNU C++, a freely redistributable C++ compiler. It is part of gcc, the GNU compiler suite, and is currently part of that distribution.
  • Decommissioned note:
g++ is now fully integrated in GCC
GDL
The Gnu Data Language (GDL) is a free alternative to the data visualization and analysis tool, called IDL (Interactive Data Language), frequently used by scientists. GDL and its library routines are designed as a tool for numerical data analysis and visualisation. GDL is dynamically typed, vectorized and has object-oriented programming capabilities. The library routines handle numerical calculations, data visualisation, signal/image processing, file input/output (incl. graphical and scientific data formats such as TIFF, PNG, netCDF, HDF etc) and interaction with host OS. Despite its name, GDL is not a GNU package.
Gcc Heckert gnu.tiny.png
GCC is the GNU Compiler Collection. It provides compiler front-ends for several languages, including C, C++, Objective-C, Fortran, Java, Ada, and Go. It also includes runtime support libraries for these languages. GCC provides many levels of source code error checking traditionally provided by other tools (such as lint), produces debugging information, and can perform many different optimizations to the resulting object code. The GNU Compiler for Java is now integrated and supported: GCJ can compile Java source or Java bytecodes to either native code or Java class files. Java programs will run faster while letting users run a completely free system without needing a proprietary Java compiler. GCC supports many different architectures and operating systems.
Gcl Heckert gnu.tiny.png
GCL is a Compiler and interpreter for Common Lisp. It compiles to C and then uses the native optimizing C compiler (e.g., GCC), giving great portability. It is highly efficient: a function call is basically the same speed as a C function call, in fact identical to a C function call via a pointer. The program has a source level Lisp debugger (dbl) for interpreted code, letting you step a line at a time, while displaying your position in an Emacs window. It has pioneered conservative Garbage Collection schemes, but also has the stratified garbage collection (SGC) scheme, for only recent allocations, that is based on native page fault handling. There is also a built in interface to Tk widget system. Allows a mixture of tcl and common lisp to be used in a user interface--your choice which you use.
Gfortran
gfortran is a freely redistributable fortran compiler. It is part of GCC, the GNU compiler suite, and is currently part of that distribution.
Ghc
The Glasgow Haskell Compiler is a robust, fully-featured, optimising compiler and interactive environment for Haskell 98, GHC compiles Haskell to either native code or C. It implements numerous experimental language extensions to Haskell 98; for example: concurrency, a foreign language interface, multi-parameter type classes, scoped type variables, existential and universal quantification, unboxed types, exceptions, weak pointers, and so on. GHC comes with a generational garbage collector, and a space and time profiler.
Gnat Heckert gnu.tiny.png
GNAT is an Ada (including Ada 2005) toolset, integrated into the GCC compiler system. Ada is a state-of-the-art programming language designed for large, long-lived applications where safety, security, and reliability are critical. GNAT includes GPS, a visual IDE, a comprehensive toolsuite including a visual debugger, and a set of libraries and bindings. As of October 2, 2001 the GNAT sources have been added to the main GCC repository where they are now synchronized almost daily with the internal Ada Core Technologies sources. See the GCC page for a full implementation of gcc.
Gnustep Heckert gnu.tiny.png
Provides an object oriented application development framework and tool set for use on a wide variety of platforms. It provides a generalized visual interface design and a cohesive user interface. It also uses a common imaging model called Display PostScript (based on PostScript) to do all its drawing, so the program is truly WYSIWYG. GNUstep is written in the Objective-C language, a simple yet powerful object-oriented language based on C that gives you the full power of an object-oriented language with exactly one syntax addition to C and a dozen or so additional keywords.
Gprolog Heckert gnu.tiny.png
Gprolog is a Prolog compiler with constraint solving over finite domains. It accepts a Prolog+ constraint program and produces a native binary. The obtained executable is now stand-alone. This executable can be quite small since GNU Prolog doesn't need to link the code of most unused built-in predicates. Besides the native code compilation, GNU Prolog offers a classical interactive interpreter (top-level). It also conforms to the ISO standard for Prolog. The program also includes an efficient constraint solver over Finite Domains (FD). This opens constraint logic programming to the user, combining its power with the declarativity of logic programming.
Guavac
This is a candidate for deletion: broken links, software not on archive.org, can't find elsewhere, no response to email to developer. Danm (talk) 14:20, 28 October 2017 (EDT) This is a Debian packaging of Effective Edge Technologies Java compiler. Guavac will allow you to write your own Java programs and applets. WARNING: guavac is orphaned upstream. It is recommended to use gcj or jikes instead. As of 2001-08-03 the home page of http://www.cs.berkeley.edu/~engberg/guavac/ was defunct.
Harbour
Harbour is a free software compiler for the xBase superset language often referred to as Clipper (the language that is implemented by the compiler CA-Clipper).
Hobbit
This program is currently part of the SCM Scheme implementation. Hobbit is a small optimizing scheme-to-C compiler written in R4RS Scheme and intended for use together with SCM scheme. It compiles full R4RS (with the exception of mutual tail recursion and hygienic macros) and supports defmacros. Hobbit treats SCM files as a C library and provides integration of compiled procedures and variables with the SCM interpreter as new primitives. It compiles scheme files to C files and does not provide anything else by itself (eg. calling the C compiler, dynamic loading). Hobbit (derived from hobbit5x) is included in SCM since 2007. Hobbit4d has also been ported to an old version of Guile.
Homebrew Decompiler
This is a candidate for deletion: Links broken. Email to maintainer broken. Poppy-one (talk) 16:17, 2 August 2018 (EDT) Homebrew Decompiler is a GPLed tool (written in C++) that takes Java .class files and reverse engineers the JVM bytecodes to generate .java files that attempt to resemble the original source code as much as possible.
Hy
Hy is a Lisp front-end to the Python AST / Bytecode. This allows you to use the Python VM just as Clojure uses the Java VM. Hy is special, since not only can Hy invoke Python, but Python can also interop with Hy in a clean way.
Icarus Verilog
Icarus Verilog is a Verilog simulation and synthesis tool. It operates as a compiler, compiling source code writen in Verilog (IEEE-1364) into some target format. For batch simulation, the compiler can generate an intermediate form called vvp assembly. This intermediate form is executed by the ``vvp command. For synthesis, the compiler generates netlists in the desired format. The compiler proper is intended to parse and elaborate design descriptions written to the IEEE standard IEEE Std 1364-2001. The standard proper was released towards the middle of the year 2001, though in a rather pricey electronic form. This is a fairly large and complex standard, so it will take some time for it to get there, but that's the goal. NOTE: Under the Version information please browse the Installation link to find the proper download link.
Java Brainfuck compiler
This is a candidate for deletion: Links broken. No archive.org entry. Email to maintainer broken. Poppy-one (talk) 13:10, 6 August 2018 (EDT) The Java Brainfuck Compiler is an optimising compiler for the Brainfuck language which produces Java bytecode.
Kawa Heckert gnu.tiny.png
Kawa is both a full-featured Scheme implementation, and a compiler toolkit for implementing other programming languages. It currently compiles the Scheme functional language to Java bytecodes. Included in Kawa is qexo, a partial implementation of XQuery in Java.
LLVM
LLVM is a compiler infrastructure designed for compile-time, link-time, runtime, and "idle-time" optimization of programs from arbitrary programming languages. It currently supports compilation of C and C++ programs, using front-ends derived from gcc 3.4.
Lazarus
Lazarus is a cross-platform IDE for developers of Free Pascal.
Liberty-eiffel Heckert gnu.tiny.png
Liberty Eiffel is a compiler for the Eiffel programming language. It continues the development of SmartEiffel, the GNU Eiffel Compiler. It is a complete, small and fast, Eiffel compiler, including an Eiffel to C compiler, documentation tools, a pretty printer, a debugger and various other tools. It also includes a large library of classes distributed under the terms of the MIT/X Consortium License and a comprehensive set of wrappers/bindings for widespread Free-Software libraries. Eiffel is an advanced object-oriented programming language that emphasizes the design and construction of high-quality and reusable software.
Lush
Lush is an object-oriented Lisp interpreter and compiler with a C interface, a vector, matrix, and tensor engine, a huge numerical library, a GUI toolkit, and bindings to GSL, SDL, OpenGL, V4l, and others. It is an alternative to Matlab, Python, and Scheme, and lets users mix Lisp and C within a single function for a unique combination of flexibility and efficiency. Lush is ideal for researchers in AI, computer vision, audio, image, and video processing, machine learning, statistics, bio-informatics, interactive graphics, and multimedia applications.
MLKit
This is a candidate for deletion: Links broken. No archive.org entry. Email to maintainer broken. Poppy-one (talk) 08:37, 1 September 2018 (EDT) The MLKit is a full-blown compiler for the programming language Standard ML. The MLKit implements most of the Basis Library and has support for ML Basis Files. The compiler runs on the Linux platform and targets the x86 architecture. The MLKit includes a graphical region profiler, which helps gain detailed control over memory reuse. The example graph to the right shows a region profile (region sizes as a function of time) of two hundred generations of the `Game of Life'. Programmers who are interested in real-time programming can exploit the possibility of disabling reference-tracing garbage collection. In this case, there will be no interruptions of unbounded duration at runtime.
MLton
MLton is a whole-program optimizing Standard ML compiler that supports the full SML 97 language. Features include a complete basis library (except for use) matching the 2002 specs, untagged native integers and reals, unboxed native arrays, fast C FFI, multiple garbage collection strategies (copying, mark contact, generational), source-level profiling of both time and allocation, and a fast IntInf based on GNUmp. It also includes libraries for continuations, finalization, heap save and restore, interval timers, random numbers, resource limits, resource usage, signal handlers, system logging, threads, weak pointers.
Matiec
This project has the goal of producing an open source compiler for the programming languages defined in the IEC 61131-3 standard. These programming languages are mostly used in the industrial automation domain, to program PLCs (Programmable Logic Controllers). This standard defines 5 programming languages: - IL : Instructtion List A textual programming language, somewhat similar to assembly. - ST : Structured Text A textual programming language, somewhat similar to Pascal. - FBD: Function Block Diagram A graphical programming language, somewhat similar to an electrical circuit diagram based on small scale integration ICs (Integrated Circuits) (counters, AND/OR/XOR/... logic gates, timers, ...). - LD : Ladder Diagram A graphical programming language, somewhat similar to an electrical circuit diagram based on relays (used for basic cabled logic controllers). - SFC: Sequential Function Chart A graphical programming language, that defines a state machine, based largely on Grafcet. (may also be expressed in textual format). Of the above 5 languages, the standard defines textual representations for IL, ST and SFC. It is these 3 languages that we target, and we currently support all three, as long as they are expressed in the textual format as defined in the standard. Currently the matiec project generates two compilers (more correctly, code translaters, but we like to call them compilers :-O ): iec2c, and iec2iec Both compilers accept the same input: a text file with ST, IL and/or SFC code. The iec2c compiler generates ANSI C code which is equivalent to the IEC 61131-3 code expressed in the input file. The iec2iec compiler generates IEC61131-3 code which is equivalent to the IEC 61131-3 code expressed in the input file. This last compiler should generate and output file which should be almost identical to the input file (some formating may change, as well as the case of letters, etc.). This 'compiler' is mostly used by the matiec project contributors to help debug the lexical and syntax portions of the compilers.
Modula-2
This is a candidate for deletion: Links to software on homepage are broken, can't find elsewhere, not on archive.org, my email to maintainer was returned to sender. Danm (talk) 16:49, 1 November 2017 (EDT) The Modula-2 System includes a compiler (for SPARCv8 under Solaris 2.x), extensive libraries, and some tools including a makefile generator. The compiler and the library predate the Modula-2 ISO standard. A Modula-2 compiler generating native code for m68k is available as well.
Mono
Mono is a free implementation of the various ECMA and .NET framework technologies for Posix, MacOS X, and Windows. The project includes a compiler, a class library, and a CLI runtime engine.
Mozart
A framework for developing user-extensible compilers and development tools. In its current state, it contains a Java to Java extensible compiler called Moka, considered in "beta" phase, and a compiler for a language called LX, in "pre-alpha" stage. It was designed with large and sophiticated software projects in mind. Mozart uses the idea of "concept programming," which makes development tools extensible, so that they understand the concepts of your application. You can describe the concepts to the development tools, and they become entities that you can manipulate the same way as built-in entities. Multiple development tools, including small and "custom" ones, can exchange program-related information in a unified format, either through persistent storage (files) or directly in memory.
Namecheck
Namecheck is a tool for static checking of symbol names using configurable rules for C and C++ code. It is currently a gcc plugin.
Nhc98
nhc98 is a small, easy to install, standards-compliant compiler for Haskell 98, the lazy functional programming language. It is very portable, and aims to produce small executables that run in small amounts of memory. It produces medium-fast code, and compilation is itself quite fast. It also comes with extensive tool support for automatic compilation, foreign language interfacing, heap and time profiling, tracing, and debugging. (Some of its advanced kinds of heap profiles are not found in any other Haskell compiler.) It supports the new common primitive FFI (Foreign Function Interface), and includes the most advanced space-profiling facilities of all Haskell implementations. Most importantly, it allows graphical debugging of programs using both Hat and HOOD. nhc98 is available for all 32-bit Unix-like platforms. Although it is itself written in standard Haskell 98, it can be quickly and easily be bootstrapped from C sources, so you do not need another Haskell compiler to get started.
Nice
Nice is an object-oriented programming language based on Java. It incorporates many advanced features from functional programming and academic research. This results in more expressivity, modularity and safety.
OfficeFloor
OfficeFloor provides true inversion of control for building simple static to complex real-time Web applications that are "build once, run anywhere" - even with cloud computing. It allows you to wire together a working prototype in minutes, extend the prototype to a working Web site in hours, and deploy and run anywhere. The code is self documenting to make support easier. It aims to be "The Java Web Answer" for rapid application development for Web applications.
Ol
Otus Lisp (Ol in short) is a purely functional dialect of Lisp. It implements an extended subset of R5RS Scheme including, but not limited to, some of the SRFIs. It's tiny(42kb), embeddable and crossplatform; can run in own sandbox; provides a portable, highlevel way for calling the code written in another languages. You can use Otus Lisp on Linux, Windows, Unix, Android and lot of any other operation systems with various (x86, x86_64, mips, arm, aarch64, ppc, etc.) architectures.
Pascal Heckert gnu.tiny.png
GNU Pascal is the Pascal language compiler of Project GNU. It is a 32/64 bit compiler that is linked against the GCC backend and will be integrated in to GCC in the long run. It runs on all operating systems compatible with GCC, and can act as a native or a cross compiler between those systems. It implements ISO Pascal, Borland Pascal 7.0, and parts of other Pascal standards or de-facto standards.
Psyco
'Psyco' helps execute Python code at speeds approaching that of fully compiled languages by using a technique called "specialization". This extension module for the unmodified interpreter accelerates user programs with little or no change in their sources. An increase in speed of 2 to 10 times is common.
PyjsioCompile
Simple compiler for jsio scripts, apps, and packages.
QDot 8086
QDot 8086 is a mid-level programming language targeting the original IBM-PC architecture written as a set of macros for NASM — the Netwide Assembler. The idea behind it is to make it easy to write small, fast, correct and maintainable code in a language almost as expressive as C but without giving up all control Assembly language grants to programmers. It features support to functions of an arbitrary number of parameters and multiple return values, global and function-local variables, loop and conditional flow-control constructs, evaluation of arbitrarily complex stack-based expressions, symbol importing and primitive debugging. In order to accomplish this, NASM’s powerful preprocessing and assembling capabilities are used to achieve a machinery that very closely resembles a compiler. QDot has also a companion standard library that is fully BIOS-based, thus OS-independent, which provides array processing, keyboard, video, disk and speaker I/O, timing, low-level debugging, math functions, user interface procedures and last but not least a versatile metamorphic boot-loader, that makes it simple to build a binary that is simultaneously a valid DOS executable and a bootable image — a property known as run-within-OS-or-bootstrap-itself-without-OS. There are already a couple of programs implemented in QDot as a proof of concept: Terminal Matrix 8086 and DeciMatrix 8086. QDot currently supports only the tiny memory model (.COM binaries — whose code, data and stack fit all within 64kb segment boundaries).
Qexo Heckert gnu.tiny.png
Qexo (Query Expressions for XML Objects aka Kawa-XQuery) is an implementation of W3C's draft XML query language XQuery. XQuery is a high-level expression language whose values are sequences of nodes (as in DOM) and simple values. It includes syntax for embedding XML or HTML results, and a 'for' statement comparable to SQL's 'select'. This implementation uses the Kawa tools to compile XQuery programs to Java bytecodes that can run on any JVM. XQuery programs can run as servlets, as standalone applications, or from the command-line.
Ragel State Machine Compiler
Ragel compiles executable finite state machines from regular languages. Ragel targets C, C++ and ASM. 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. Code embedding is done using inline operators that do not disrupt the regular language syntax.
SNACC
Given an ASN.1 source file SNACC can produce C routines for BER encoding, decoding, printing, and freeing; C++ routines for BER encoding, decoding, and printing; and a type table that can be used with generic C routines for BER encoding, decoding, printing, and freeing. SNACC produces reasonably efficient C or C++ routines and data structures values of the given ASN.1 data structures, as well as printing routines for the decoded values. For C only, the program generates hierarchical freeing routines (but for efficiency reasons this is not recommended). The SNACC compiler and the generated code will compile under both ANSI and non-ANSI C compilers.
SableCC
'SableCC' is an object-oriented framework that generates compilers and interpreters in Java. It is based on two design decisions. First, the framework uses object-oriented techniques to automatically build a strictly typed abstract syntax tree. Second, the framework generates tree-walker classes using an extended version of the visitor design pattern which enables the implementation of actions on the nodes of the abstract syntax tree using inheritance. This means a shorter development cycle for constructing compilers.
Sather Heckert gnu.tiny.png
Sather is an object-oriented programming language similar to Eiffel. It is designed to be simple, efficient, safe, and non-proprietary. It features garbage collection, statically-checked strong typing, multiple inheritance, parameterized classes and more. This package consists of a compiler, a class library, the language specification and programming manual, and a browser for displaying sources and directed graphs of class inheritance.
Scons-chicken
This is a candidate for deletion: Links broken. No links to page. Maintainer response to email is "I'm not personally maintaining it anymore, so, I doubt it is maintained."Poppy-one (talk) 17:40, 28 July 2018 (EDT) Scons-chicken adds support for SCons to compile Chicken based projects. It aims to be as simple as possible and as automatic as possible supporting all possible features of Chicken, like making and using extensions, generating the .setup files, etc.
Sdcc
"Small Device C Compiler" is a retargetable, optimizing ANSI C compiler. The current version targets the Intel 8051 and recently the Zilog Z80 based MCUs., but can be retargeted for other 8 bit MCUs or PICs. SDCC uses ASXXXX and ASLINK, a retargettable assembler and linker. SDCC has extensive MCU specific language extensions, which lets it effectively use the underlying hardware. The front end (parser) will be enhanced as targeted to handle language extensions for other MCUs. In addition to the MCU Specific optimizations, SDCC does a host of standard optimizations like global sub expression elimination, loop optimizations (loop invariant, strength reduction of induction variables and loop reversing), constant folding and propagation, copy propagation, dead code elimination and jump tables for 'switch' statements.
Shake(build tool)
Shake is a Haskell library for writing build systems - designed as a replacement for make. See "Development.Shake" for an introduction, including an example. Further examples are included in the Cabal tarball, under the Examples directory. The homepage contains links to a user manual, an academic paper and further information: <http://www.shakebuild.com/> To use Shake the user writes a Haskell program that imports "Development.Shake", defines some build rules, and calls the 'Development.Shake.shakeArgs' function. Thanks to do notation and infix operators, a simple Shake build system is not too dissimilar from a simple Makefile. However, as build systems get more complex, Shake is able to take advantage of the excellent abstraction facilities offered by Haskell and easily support much larger projects. The Shake library provides all the standard features available in other build systems, including automatic parallelism and minimal rebuilds. Shake also provides more accurate dependency tracking, including seamless support for generated files, and dependencies on system information (e.g. compiler version).
Smarteiffel
SmartEiffel is a research and free software project that provides the Eiffel community with a mature and free compiler, an extensive and entirely object-oriented class library and a set of Eiffel-specific tools needed for a complete development environment, as an Eiffel-level symbolic debugger or a documentation tool.
Snescom
snescom is a suite of assembler and linker tools for the 65816 processor, which is used in the SNES. It can produce xa65-compatible relocatable object files, IPS format patches, raw binary images, and ROM images in SMC format.
State Machine Compiler
'SMC' takes a state machine stored in an .sm file and generates the state pattern classes in C++, Java, or [incr Tcl]. No more hand-maintained transition matrices or widely scattered switch statements. The state diagram is now in one place, coded directly from the picture to the SMC language and easily maintained. Dealing with unexpected events is a must for a robust application. By combining virtual methods with the state pattern, SMC lets you define "Default" transitions - transitions which allow your objects to handle unexpected events, recover and continue providing service.
Steel Bank Common Lisp
Steel Bank Common Lisp is a development environment for Common Lisp. It supports almost all of the ANSI standard: garbage collection, lexical closures, powerful macros, strong dynamic typing, incremental compilation, and the Common Lisp object system (multimethods and all). It also includes some extensions, such as an interface to call out to C. These are all available through an integrated native compiler, plus the usual Lispy integrated interpreter and high level debugging support.
Superopt Heckert gnu.tiny.png
GNU superoptimizer is a function sequence generator that uses exhaustive generate-and-test approach to find the shortest instruction sequence for a given function. You must tell the superoptimizer which function and which CPU you want to get code for. It cannot generate very long sequences unless you have a very fast computer.
TCLP
TCLP is a type checker for Prolog dialects. Its goal is to statically trap programming errors like illegal arguments used in a call for a predicate or illegally built data structures with respect to a given typing for function symbols or predicates. TCLP is also capable of type inference for user predicates. It supports ISO-Prolog, GNU-Prolog, and SICStus Prolog.
Tiny C Compiler
TCC (Tiny C Compiler) is small, fast, unlimited, and safe. You can compile and execute C code everywhere (e.g., on rescue disks). It generates optimized x86 code, and can compile, assemble, and link several times faster than 'gcc -O0'. Any C dynamic library can be used directly. It includes an optional memory and bounds checker, and bounds-checked code can be mixed freely with standard code. C script is also supported--just add '#!/usr/bin/tcc' at the first line of your C source, and execute it directly from the command line.
Tiny COBOL
Tiny COBOL is a COBOL compiler designed to implement the COBOL 85 standard. It also conforms to some of the COBOL-2002 standard. This package, actively developed in the 2000 years by members of the free software community, is no longer maintained.
Tvmet
This Tiny Vector and Matrix template library uses Meta Templates and Expression Templates (ET) to evaluate results at compile time, thus making it fast for low-end systems. The code produced is similar to hand-coded code, but its quality still depends on the compiler and its version. The dimensions for vectors and matrices are static and bounded at compile time using template arguments.
Uz80as
uz80as is an assembler for the Zilog Z80 and several other microprocessors. It accepts source files with the same syntax accepted by the Telemark Cross Assembler (TASM), with only minor differences. Currently, uz80as can assemble for these microprocessors: - Z80 family - Zilog Z80 - Hitachi HD64180 - Sharp LR35902 (Nintendo Gameboy CPU) - 6500 family - MOS Technology 6502 - California Micro Devices G65SC02 - Rockwell R6501, R65C02, R65C29 - Western Design Center W65C02S - Datapoint 2200 (versions I & II) - Intel 4004, 4040, 8008, 8021, 8022, 8041, 8048, 8051, 8080, 8085 - Motorola 6800, 6801, 68HC11
White dune
With 'white_dune' you can create/change 3D objects and animate them (in a easy way if you choose the -4kids GUI). The result can be shown in any webgl enabled web browser or converted to theRenderman Image Bytestream format for movie creation. 'white_dune' is a graphical editor, a simple NURBS/Superformula/Subdivision 3D modeller, and a animation tool for the VRML97(Virtual Reality Modelling Language)/X3D, which is the ISO standard for displaying 3D data over the web via browser plugins (or webgl via X3DOM or X_ITE javascript) . It supports animation, realtime interaction and multimedia (image, movie, sound). Dune reads VRML97/X3D files, displays, and let the user change scenegraphs/fields. 'white_dune' can also translate a VRML97/X3D file to C, C++ or java. The resulting file can be rendered with OpenGL/jogl. Under GNU/Linux white_dune is a immersive VRML editor. It has support for stereoscopic view via "quadbuffer" capable stereo visuals and support for various 3D input devices supported by the X11 XInput or Linux joystick interface.
Z80-ASM
'Z80-ASM' contains a compiler for the Z80 assembling language and a monitor including an interactive debugger. The compiler is a two-pass one, which knows all documented Z80 instructions. It has labels, comments and can even evaluate constant arithmetic expressions. The debugger is interactive; it shows content of all registers, memory, stack, program. You can trace programs step by step, modify registers and contents of memory, and load and save parts of memory.
Gnucobol Heckert gnu.tiny.png
GnuCOBOL is a modern COBOL compiler. It implements a substantial portion of the COBOL 85, COBOL 2002, COBOL 2014 and X/Open COBOL standards, as well as many extensions included in other COBOL compilers (IBM COBOL, MicroFocus COBOL, ACUCOBOL-GT and others) GnuCOBOL translates COBOL into C and compiles the translated code using a native C compiler.


Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the page “GNU Free Documentation License”.

The copyright and license notices on this page only apply to the text on this page. Any software or copyright-licenses or other similar notices described in this text has its own copyright notice and license, which can usually be found in the distribution or license text itself.