Compiler

This project is a small compiler, that compiles my own little language into X86-64 Assembly. It then uses yasm and ld to assemble and link into a Linux X86-64 executable.

But why?

I've always wanted to write a compiler myself! But just never got around to do it. So the current Coronavirus quarantine situation finally gives me enough time to tackle it myself.

And I was really impressed by people, that wrote solutions for last years adventofcode.com in their own language. So that is something I'd like to achieve :)

I like to work on challenging problems and found compilers intriguing.

How to run

go build
./compiler <source_file>
./executable

The compiler will always create an executable called executable. Additionally, it will create a file source.asm that contains the generated (not optimized) assembly.

Dependencies

Everything is written from scratch, there are no code dependencies. But to assemble and link the program into an executable, you need:

yasm
ld

The resulting Assembly also has no external dependencies (No C std lib, printing is implemented in Assembly directly).

Language influences

Go
C
Python
Lua

Features

Strong and static type system
Multiple return values from functions
Automatic packing/unpacking of multiple arguments and/or function returns
Function overloading
Function inlining (only for system functions right now)
Dynamic Arrays with an internal capacity, so not every append needs a new memory allocation
Int, Char, String and Float types are always 64bit
Very Python-like array creation
Switch expressions match either values or general boolean expressions
Range-based Loops with index and element
Structs

Examples

See the compiler_test.go file for a lot more working examples :)

Print

// There are overloaded functions: print, println that work on int, float, char, bool and string
println(5)
println(6.543)
println('b')
println("abc")
println(true)

Assignment

// Types are derived from the expressions!
a = 4
b = 5.6
c = true
d = 'f'
e = "abc"
f = a + 5 + int(b) // 14

Functions

fun abc(i int, j float) int, float, char, string {
    return i, j, 'b', "abc"
}
// Can be overloaded
fun abc(i int, j int) int, float, char, string {
    return i, 5.5, 'a', "abc"
}
// ...
a, b, c, d = abc(5, 6.5)

Lists

// List of integers. Type derived from the expressions. Every values must have the exact same type.
list = [1, 2, 3, 4, 5]
// Strings can be explicitely defined as a list of chars or implicitely by using string literals
// Internally, they are handled the same way.
chars = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
str = "abcdefg"

// Empty list of integers with length 10. Type explicitely set
list2 = [](int, 10)
// Lists can naturally contain other lists
list3 = [list, list2]
// There are build-in functions, to get the length and capacity
println(len(list3))
println(cap(list3))

// You have to free them yourself
free(list)

// And some convenience functions to clear/reset the list without deallocating the memory:
// reset only resets the length, while clear overwrites the memory with 0s
reset(list)
clear(list)

// Build-in append/extend function, similar to the one in Go
// Careful ! append/extend works on the first argument. Depending on the available capacity, it will
// extend list or free list and create a completely new memory block, copy list and list2 over and return
// the new pointer!
list = append(list, 6)
list = extend(list, list2)

// Lists in functions/structs
fun abc(a []int) {
    // ...
}

Loops

list = [1,2,3,4,5]

for i = 0; i < len(list); i++ {
    // ...
}

for i,e : list {
    // i is the current index
    // e is the actual element: list[i]
}

for i, c : "abcdefg" {
    print(c)
}
// will print in: abcdefg

Conditions

a = true
b = 3 > 4
if a && !b {
    println("abc")
}

Switch

// We have no fallthrough
switch 4 {
case 1:
    println("case 1")
case 2, 3, 6:
    println("case 2")
case 5:
    println("case 3")
default:
    println("default case")
}

// switches do not need a value to check against.
// With no value provided, each case will be checked after each other for an expression that evaluates to true.
switch {
case 2 > 3:
    println("case 1")
case 2 == 3:
    println("case 2")
default:
    println("default case")
}

Structs

struct B {
    i int
    j int
}
struct A {
    i int
    j B
}

// Structs are created by calling a function with the same name and an exact match of parameters
// that match the expected types of the struct.
// Internally, this is just syntax, not a function. So there is no overhead!
a = A(1, B(3, 4))
a.j.j = 100
println(a.i)
println(a.j.j)

Type conversions

// Build-in (inline) functions: int(), float()
println(int(5.5))
println(float(5))

// Chars can be converted from and to int (ascii value) by using char() or int()
println(int('a'))
println(char(98))

MauriceGit/compiler

ErrorLooks like something went wrong!

About

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Languages

Error
Looks like something went wrong!

Packages