I Wrote A Compiler For My Custom 16-Bit Computer

Welcome, fellow thinkers and creators, to a fascinating journey into the world of programming and compilers. Today, we delve into the intricate process of writing a compiler, a program that translates code from a high-level language to assembly language. But fear not, my friends, for we shall embark on this adventure with creativity, humor, and a positive spirit.

The Power of Assembly and the Need for Compilers

Let us begin by acknowledging the power of assembly language, where every instruction is carefully crafted to interact directly with the computer's hardware. It is a language of efficiency and control. However, as brilliant as assembly may be, it can be a time-consuming endeavor to write large programs solely in this language.

To overcome this challenge, we turn to the mighty compilers. These programs, like any other, take code written in a higher-level language (such as C) and translate it back into assembly language. This way, we can focus on writing code in a more human-friendly language, saving us time and effort.

Hello World: A Tradition of Programming

As is tradition in the world of programming, let us start with the iconic "Hello World" program. With our newly created compiler, we can easily compile this program, translating it into assembly code. Then, we assemble it to obtain a binary file, ready for execution.

And voila, there it is, our "Hello World" message printed on the screen. But let's not stop there, my friends. We can unleash our creativity and modify the code to do so much more than just printing "Hello World."

Understanding the Magic: Parsing and Tokenization

Now, let us delve into the inner workings of our compiler. The process begins with parsing, where we strive to understand the source code and convert it into a more structured form. We start by tokenizing the code, replacing sequences of characters with tokens.

For example, every occurrence of the keyword "int" becomes an "ink" token, making our code more concise and easier to handle. We no longer have to deal with individual characters; instead, we have a list of tokens that represent the essential elements of our program.

From Tokens to Abstract Syntax Trees

With our tokens in hand, we move on to the next step: building an abstract syntax tree. This tree structure represents the structure of our program, allowing us to express its logic and flow. Each node in the tree corresponds to a statement or expression in our code.

Parsing is the process of traversing this list of tokens and constructing the abstract syntax tree. We match the tokens with the possible statements and expressions in the language, fitting the details together like puzzle pieces. If a token does not match any expected statement, it is an error.

The Magic of Code Generation

Once we have our abstract syntax tree in place, we enter the final stage: code generation. Here, we transform the abstract syntax tree into assembly code. This may seem like a daunting task, as the tree structure and assembly code look nothing alike. But fear not, my friends, for we shall conquer this challenge with a systematic approach.

We divide the problem into smaller parts, creating functions that generate assembly code for each type of node in the tree. By instructing the top node (the function node) to generate its code, we initiate a cascading effect, where each statement and expression generates its own code.

The result? Our abstract syntax tree magically transforms into assembly code, ready to be executed. And all of this, my friends, can be accomplished in a fraction of a second by our compiler.

From Factorial to printf: Unleashing the Compiler's Power

Now that we understand the basics of our compiler, let us explore its capabilities further. We can go beyond simple programs like "Hello World" and tackle more complex tasks, such as computing