Programming Languages on grzenow

Latte Compiler

Sun, 21 Jan 2024 00:00:00 +0000

One of the major projects during my graduate studies was building a compiler for the Latte language, extended with features such as arrays, structs, and objects with single inheritance. The compiler parses Latte code using the BNFC tool and compiles it into x86 assembly.

The compiler’s core is implemented using a Reader-Writer-State monad:

data Reader = Rd
 { func :: Map.Map String TType
 , clss :: Map.Map String ClassEnv
 }
type Writer = [AsmInstr]
data State = St
 { nextlab :: Int
 , newloc :: Int
 , env :: Map.Map String (TType, String)
 , rodata :: Map.Map String String
 , rspOff :: Int
 }

where

Instant Compiler

Sat, 28 Oct 2023 00:00:00 +0000

Instant is a programming language that supports two types of statements:

expression - prints the value of the expression on stdout,
variable = expression - assigns the value of the expression to the variable.

Expressions can consist of integers, variables, and arithmetic operations between them.

The goal of this project was to create a compiler from Instant to JVM and LLVM architectures.

A detailed description can be found here.

Source code

Latte Interpreter

Wed, 10 May 2023 00:00:00 +0000

One of the larger projects I did during my undergraduate studies is undoubtedly an interpreter for the simple programming language Latte.

The interpreter is written in Haskell, and the grammar is parsed into this language using the BNFC tool. The implemented functionalities are described in detail on GitHub (link below), along with numerous examples, so below is a brief overview of the implementation details.

The code of the Latte language is automatically parsed by BNFC and then passed to static type checking. The monad representing the state of the TypeChecker looks as follows:

Pętlik

Tue, 19 Jan 2021 00:00:00 +0000

Pętlik is a small programming language, which syntax is defined by the following grammar with the start symbol Program:

Program → InstructionSequence
InstructionSequence → ε | InstructionSequence Instruction
Instruction → Increment | Repeat
Increment → Variable
Repeat → '(' Variable InstructionSequence ')'
Variable → 'a' | ... | 'z'

Instructions:

Increment: equivalent to ++variable in C, incrementing the variable by 1.

Repeat: equivalent to a C-style while loop:

while (variable > 0) {
 --variable;
 ...
}

The project consist of two components: