Compiler Basics

From Recipe to Meal

A computer program is a set of instructions, much like a recipe. The problem is, computers don't understand human languages like English. They speak a low-level language called machine code, which looks like a long series of ones and zeros. Writing directly in machine code is incredibly tedious and difficult for humans.

This is where a compiler comes in. A compiler is a special program that acts as a translator. It takes the human-readable instructions you write, called source code, and converts them into machine code that the computer's processor can execute. This process is called compilation.

Compilation

noun

The process of converting source code written in a high-level programming language into a lower-level language, such as machine code, to create an executable program.

Think of a chef who finds a handwritten family recipe. The recipe (source code) has instructions like "add a pinch of salt" and "bake until golden brown." The chef's brain acts as a compiler. It first analyzes the recipe to understand the ingredients and steps. Then, it synthesizes this understanding into a series of actions: grabbing the salt, preheating the oven, and setting a timer. The final result is a delicious meal (the executable program).

The compiler's work is typically split into two major phases. The front-end analyzes the source code to check for errors and build an intermediate representation of what the code is trying to do. It’s like the chef reading the recipe to make sure all the ingredients are listed and the steps make sense. The back-end then takes this intermediate representation and synthesizes the final machine code, optimizing it for the target computer. This is the chef actually executing the steps to cook the meal efficiently.

Setting Up Your Kitchen

To start building our own compiler, we first need a basic C development environment. This means having a text editor to write code and a C compiler to translate it. We will use C because it's powerful and gives us low-level control, which is perfect for understanding how things work under the hood. For our compiler, we'll rely on GCC, a popular and powerful open-source compiler.

Most Linux and macOS systems come with GCC or a compatible compiler like Clang pre-installed. To check, open your terminal and type:

gcc --version

If you see version information, you're all set. If not, you can easily install it. On Debian/Ubuntu, use sudo apt install build-essential. On macOS, installing the Xcode Command Line Tools will provide it.

Reading the Recipe

The first job of any compiler is to read the source code file. Let's write a simple C program that opens a file named test.txt and prints its contents to the screen. This small step is the foundation of our compiler's front-end. It's how we get the "recipe" into our "kitchen."

#include <stdio.h>
#include <stdlib.h> // For exit()

int main() {
    FILE *file_pointer;
    int character;

    // Open the file in read mode
    file_pointer = fopen("test.txt", "r");

    // Check if the file was opened successfully
    if (file_pointer == NULL) {
        printf("Could not open file test.txt\n");
        exit(1); // Exit the program with an error
    }

    // Read and print one character at a time until the end of the file
    while ((character = fgetc(file_pointer)) != EOF) {
        printf("%c", character);
    }

    // Close the file
    fclose(file_pointer);

    return 0;
}

Let's break this down:

#include <stdio.h>: This line includes the standard input/output library, which gives us functions like fopen() and printf().
FILE *file_pointer;: This declares a pointer that will hold the reference to our file.
fopen("test.txt", "r"): This function attempts to open a file named test.txt in "read" mode.
fgetc(file_pointer): This reads the next character from the file.
while (...) != EOF: The loop continues as long as we haven't reached the EOF (End-Of-File) marker.
fclose(file_pointer): This closes the file, releasing it from our program's control. It's good practice, like washing your dishes after cooking.

Now that we can read a file, we have taken the first step toward building a compiler. Next, we'll start analyzing the text we've read.

Building a Compiler from Scratch