fcc - Fedjmike's C Compiler

  •        3

Dependencies: C standard library, a POSIX cc for assembly and linking. The compiler implements a language quite similar to C, but there are some major differences. The following list is probably not exhaustive, but attempts to be.

https://github.com/Fedjmike/fcc

Tags
Implementation
License
Platform

   




Related Projects

mini-c - Dr Strangehack, or: how to write a self-hosting C compiler in 10 hours

  •    C

I set myself a challenge: write a self-hosting C compiler in 10 hours. This is the result, plus lots of cleanup (check "releases" for the 10 hour version). The general philosophy was: only include a feature if it reduces the total code size. This is taken to its extreme in the insane branch.

CodeCommander

  •    

CodeCommander is a code generator and makes it easier for developers to construct a source code. You'll no longer have to write your source code twice a week. It's developed in C# .NET V2.0

OILexer

  •    CSharp

OILexer is a LL parser generator for C# aimed at simple language parsing for language enthusiasts. Does not use recursive descent or bottom-up parsing methods, but rather, a top-down deterministic model is employed. This is a portion of the Abstraction Project.

glow - Compiler for Neural Network hardware accelerators

  •    C++

Glow is a machine learning compiler and execution engine for various hardware targets. It is designed to be used as a backend for high-level machine learning frameworks. The compiler is designed to allow state of the art compiler optimizations and code generation of neural network graphs. This library is experimental and in active development. Glow lowers a traditional neural network dataflow graph into a two-phase strongly-typed intermediate representation (IR). The high-level IR allows the optimizer to perform domain-specific optimizations. The lower-level instruction-based address-only IR allows the compiler to perform memory-related optimizations, such as instruction scheduling, static memory allocation and copy elimination. At the lowest level, the optimizer performs machine-specific code generation to take advantage of specialized hardware features. Glow features a lowering phase which enables the compiler to support a high number of input operators as well as a large number of hardware targets by eliminating the need to implement all operators on all targets. The lowering phase is designed to reduce the input space and allow new hardware backends to focus on a small number of linear algebra primitives. The design philosophy is described in an arXiv paper.

mcsema - Framework for lifting x86, amd64, and aarch64 program binaries to LLVM bitcode

  •    C++

McSema is an executable lifter. It translates ("lifts") executable binaries from native machine code to LLVM bitcode. LLVM bitcode is an intermediate representation form of a program that was originally created for the retargetable LLVM compiler, but which is also very useful for performing program analysis methods that would not be possible to perform on an executable binary directly. McSema enables analysts to find and retroactively harden binary programs against security bugs, independently validate vendor source code, and generate application tests with high code coverage. McSema isn’t just for static analysis. The lifted LLVM bitcode can also be fuzzed with libFuzzer, an LLVM-based instrumented fuzzer that would otherwise require the target source code. The lifted bitcode can even be compiled back into a runnable program! This is a procedure known as static binary rewriting, binary translation, or binary recompilation.


qone - Next-generation web query language, extend .NET LINQ for javascript.

  •    Javascript

Recently, it has just changed some bug of the Excel formula of the Tencent document, mainly modifying the parser of the formula. After getting code string, you can run (JIT) dynamically, such as using Eval in JS, Eval can retain context information, the disadvantage is that the execution code contains compiler code, and it is unsafe, and so on. After getting code string, you can also use the generated code string to run (AOT) directly, and the disadvantage is to rely on the build tool or editor plug-in to dynamically replace the source code.

flrc - Haskell Research Compiler

  •    Standard

FLRC requires FLRC-LIB to be installed prior to its installation. Other software required are autoconf/automake, pkg-config, the MLton compiler, and a C/C++ compiler. All released code has only been tested to work on x86 64-bit Linux distros, although they were originally written for x86 32-bit Windows. At least 4GB of free memory is advised for compiling FLRC.

SoftWire

  •    Assembly

SoftWire was the precursor to TransGaming's SwiftAsm. SwiftAsm is an optimizing run-time x86 assembler that can be used as a JIT compiler back-end for scripting languages, or for dynamic code generation of efficient processing pipelines.

CompCert - The CompCert formally-verified C compiler

  •    Coq

The verified C compiler. The CompCert C verified compiler is a compiler for a large subset of the C programming language that generates code for the PowerPC, ARM, x86 and RISC-V processors.

forevalz

  •    Delphi

ForevalZ - compiler of mathematical expressions(formulas)(directly in FPU x86) with complex numbers given as string at 'run-time'. (dll library and delphi component)(math parser, math expression parser, evaluate formula, evaluator, calculate)

foreval

  •    Delphi

Foreval is compiler of mathematical expressions (formulas) (directly to FPU x86) given as string at run-time. (dll library and delphi component) .(math parser,math expression parser,evaluate formula, evaluator)

avo - Generate x86 Assembly with Go

  •    Go

Note: APIs subject to change while avo is still in an experimental phase. You can use it to build real things but we suggest you pin a version with your package manager of choice. go run this code to see the assembly output. To integrate this into the rest of your Go package we recommend a go:generate line to produce the assembly and the corresponding Go stub file.

red - Red is a next-generation programming language strongly inspired by Rebol, but with a broader field of usage thanks to its native-code compiler, from system programming to high-level scripting and cross-platform reactive GUI, while providing modern support for concurrency, all in a zero-install, zero-config, single 1MB file!

  •    Red

Red is a new programming language strongly inspired by Rebol, but with a broader field of usage thanks to its native-code compiler, from system programming to high-level scripting, while providing modern support for concurrency and multi-core CPUs. Red has its own complete cross-platform toolchain, featuring two compilers, an interpreter and a linker, not depending on any third-party library, except for a Rebol2 interpreter, required during the bootstrap phase. Once complete, Red will be self-hosted.

PeachPy - x86-64 assembler embedded in Python

  •    Python

PeachPy is a Python framework for writing high-performance assembly kernels. Now you can compile this code into a binary object file that you can link into a program...

Open Source Compiler, Optimizer and Interpreter for a C-Like Language

  •    

Here, you can download an open-source compiler, optimizer and multi-core code generator for a C-like language and modify it in order to meet your requirements.

virtualization-lms-core - A Framework for Runtime Code Generation and Compiled DSLs

  •    Scala

Lightweight Modular Staging (LMS) is a runtime code generation approach. This framework, LMS-Core, provides a library of core components for building high performance code generators and embedded compilers in Scala. Closely related projects are Delite, a framework for heterogeneous parallel domain specific languages (DSLs), and Scala-Virtualized, a set of minimal extensions to the Scala compiler to make embedding DSLs more seamless.

gnostic - A compiler for APIs described by the OpenAPI Specification with plugins for code generation and other API support tasks

  •    Swift

This repository contains a Go command line tool which converts JSON and YAML OpenAPI descriptions to and from equivalent Protocol Buffer representations. Protocol Buffers provide a language-neutral, platform-neutral, extensible mechanism for serializing structured data. gnostic's Protocol Buffer models for the OpenAPI Specification can be used to generate code that includes data structures with explicit fields for the elements of an OpenAPI description. This makes it possible for developers to work with OpenAPI descriptions in type-safe ways, which is particularly useful in strongly-typed languages like Go and Swift.

DAE Tools Project

  •    C++

Equation-oriented process modelling and optimization software

John's Mutant

  •    Assembly

John's Mutant contains a compiler for the mutant language. It is written in python, and emits NASM source code for 16bit DOS, x86 Linux, and x86_64 LInux. This is the successor to the Burapha Compiler Kit.