compiler

This repository contains the code for a compiler implementation written in the C programming language that relies on the tools Flex and Bison. The target language is a simple, C-like language.

Prerequisites

• GCC (GNU Compiler Collection)
• Make
• Flex (derivative of Lex)
• Bison (derivative of Yacc)
• Jansson library (for debugging purposes)
• MIPS32 Simulator (for original implementation)

Basic Installation

Linux

For Arch-based distributions:

sudo pacman -Syu
sudo pacman -S --needed base-devel jansson

[!NOTE] base-devel includes gcc, make, flex, bison, and other core development tools. Alternatively, you can install each separately.

For Debian-based distributions:

sudo apt update
sudo apt install build-essential flex bison libjansson-dev

[!NOTE] build-essential includes gcc, make, and other core build tools. Alternatively, you can install each separately.

For Fedora-based distributions:

sudo dnf makecache
sudo dnf group install development-tools
sudo dnf install flex flex-devel bison bison-devel jansson jansson-devel

[!NOTE] development-tools group includes gcc, make, and other core build tools. Alternatively, you can install each separately.

Microsoft Windows

It is highly recommended that you use a Linux distribution instead, through any method you prefer.

Options include:

• Windows Subsystem for Linux (WSL), preferably version 2
• Docker or Podman containers
• Virtual Machines

macOS

I am not very familiar with Macintosh systems. However, it seems that you first need to install Apple's command-line developer tools, which will provide you with make, clang and gcc (via clang), as well as other development tools. Next, install a package manager such as Homebrew (brew), through which you can then install flex, bison and jansson.

xcode-select --install
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
brew install flex bison jansson

Getting Started

Building the compiler from source

Clone the repository and change into the directory:

git clone https://github.com/drifter1/compiler.git
cd compiler

To build the compiler simply type make in this directory.

By default, the executable will be located in the subdirectory bin and called compiler.

Running the included examples

Examples are included in the examples directory.

By default, typing make run will compile example1.c from the simple_c_examples subdirectory using the compiled binary from make. It's essentially the same as:

./bin/compiler examples/simple_c_examples/example1.c

[!NOTE] By default, the compiler prints debugging information to the terminal console and creates debugging files with extensions .out and .json. Debugging can be disabled by setting the DEBUG flag to 0 in include/compiler.h or by adding the flag -DDEBUG=0 to gcc compilation in the Makefile, which has the same effect.

Cleaning up the build files and binaries

To clean the build files and binary executable, you just have to type make clean.

Cleaning up the run files

To clean the debugging files when using the compiler in DEBUG mode (the default setting), simply type make clean-run after make run.

Articles

A comprehensive tutorial series is also available, which should cover most aspects of the original implementation.

The complete list of articles can be found here.

[!IMPORTANT] Please be advised that significant changes have been made to the source code and repository (issue #5), meaning that the tutorial series and repository are no longer perfectly aligned. The tutorial series has also been discontinued. It is planned for the repository to have helpful, detailed documentation instead. The final commit prior to the major overhaul is 7fbcd3f. It should help you work your way through the series more easily, since every single article has its own folder.

Simple C Language

The programming language is being explained here.

Current Status

• Intermediate code generation (issue #14)

Next Steps

• Machine code generation (The original implementation targeted MIPS Assembly. Might now switch to RISC-V instead).
• Further optimizations and enhancements in the compiler's source code